class Bio::Alignment::OriginalAlignment

Bio::Alignment::OriginalAlignment is the BioRuby original multiple sequence alignment container class. It includes HashExtension.

It is recommended only to use methods defined in EnumerableExtension (and the #each_seq method). The method only defined in this class might be obsoleted in the future.

Attributes

keys[R]

identifiers (or definitions or names) of the sequences

Public Class Methods

new(seqs = []) click to toggle source

Creates a new alignment object. seqs may be one of follows: an array of sequences (or strings), an array of sequence database objects, an alignment object.

# File lib/bio/alignment.rb, line 1548
def initialize(seqs = [])
  @seqs = {}
  @keys = []
  self.add_sequences(seqs)
end
new2(*arg) click to toggle source

Creates a new alignment object from given arguments.

It will be obsoleted.

# File lib/bio/alignment.rb, line 1539
def self.new2(*arg)
  self.new(arg)
end
readfiles(*files) click to toggle source

Read files and creates a new alignment object.

It will be obsoleted.

# File lib/bio/alignment.rb, line 1525
def self.readfiles(*files)
  require 'bio/io/flatfile'
  aln = self.new
  files.each do |fn|
    Bio::FlatFile.open(nil, fn) do |ff|
      aln.add_sequences(ff)
    end
  end
  aln
end

Public Instance Methods

<<(seq) click to toggle source

Adds a sequence without key. The key is automatically determined.

# File lib/bio/alignment.rb, line 1703
def <<(seq)
  #(Array-like)
  self.store(nil, seq)
  self
end
==(x) click to toggle source

If x is the same value, returns true. Otherwise, returns false.

# File lib/bio/alignment.rb, line 1556
def ==(x)
  #(original)
  if x.is_a?(self.class)
    self.to_hash == x.to_hash
  else
    false
  end
end
[](*arg) click to toggle source

Gets a sequence. (Like Hash#[])

# File lib/bio/alignment.rb, line 1710
def [](*arg)
  #(Hash-like)
  @seqs[*arg]
end
__store__(key, seq) click to toggle source

stores a sequences with the name

key

name of the sequence

seq

sequence

# File lib/bio/alignment.rb, line 1609
def __store__(key, seq)
  #(Hash-like)
  h = { key => seq }
  @keys << h.keys[0]
  @seqs.update(h)
  seq
end
add_seq(seq, key = nil) click to toggle source

Adds a sequence to the alignment. Returns key if succeeded. Returns nil (and not added to the alignment) if key is already used.

It resembles BioPerl's AlignI::add_seq method.

# File lib/bio/alignment.rb, line 1899
def add_seq(seq, key = nil)
  #(BioPerl) AlignI::add_seq like method
  unless seq.is_a?(Bio::Sequence::NA) or seq.is_a?(Bio::Sequence::AA)
    s =   extract_seq(seq)
    key = extract_key(seq) unless key
    seq = s
  end
  self.store(key, seq)
end
add_sequences(seqs) { |x| ... } click to toggle source

Adds sequences to the alignment. seqs may be one of follows: an array of sequences (or strings), an array of sequence database objects, an alignment object.

# File lib/bio/alignment.rb, line 1576
def add_sequences(seqs)
  if block_given? then
    seqs.each do |x|
      s, key = yield x
      self.store(key, s)
    end
  else
    if seqs.is_a?(self.class) then
      seqs.each_pair do |k, s|
        self.store(k, s)
      end
    elsif seqs.respond_to?(:each_pair)
      seqs.each_pair do |k, x|
        s = extract_seq(x)
        self.store(k, s)
      end
    else
      seqs.each do |x|
        s = extract_seq(x)
        k = extract_key(x)
        self.store(k, s)
      end
    end
  end
  self
end
alignment_collect() { |s| ... } click to toggle source

Iterates over each sequence and each results running block are collected and returns a new alignment.

The method name 'collect_align' will be obsoleted. Please use 'alignment_collect' instead.

# File lib/bio/alignment.rb, line 1858
def alignment_collect
  #(original)
  na = self.class.new
  na.set_all_property(get_all_property)
  self.each_pair do |k, s|
    na.store(k, yield(s))
  end
  na
end
Also aliased as: collect_align
collect!() { |seqs| ... } click to toggle source

Iterates over each sequence, replacing the sequence with the value returned by the block.

# File lib/bio/alignment.rb, line 1750
def collect!
  #(Array-like)
  @keys.each do |k|
    @seqs[k] = yield @seqs[k]
  end
end
collect_align()
Alias for: alignment_collect
compact() click to toggle source

Removes empty sequences or nil and returns new alignment. (Like Array#compact)

# File lib/bio/alignment.rb, line 1887
def compact
  #(Array-like)
  na = self.dup
  na.compact!
  na
end
compact!() click to toggle source

Removes empty sequences or nil in the alignment. (Like Array#compact!)

# File lib/bio/alignment.rb, line 1871
def compact!
  #(Array-like)
  d = []
  self.each_pair do |k, s|
    if !s or s.empty?
      d << k
    end
  end
  d.each do |k|
    self.delete(k)
  end
  d.empty? ? nil : d
end
concat(aln) click to toggle source

Concatenates a string or an alignment. Returns self.

Note that the method will be obsoleted. Please use each_seq { |s| s << str } for concatenating a string and alignment_concat(aln) for concatenating an alignment.

# File lib/bio/alignment.rb, line 2032
def concat(aln)
  #(String-like)
  if aln.respond_to?(:to_str) then #aln.is_a?(String)
    self.each do |s|
      s << aln
    end
    self
  else
    alignment_concat(aln)
  end
end
delete(key) click to toggle source

Removes the sequence whose key is key. Returns the removed sequence. If not found, returns nil.

# File lib/bio/alignment.rb, line 1689
def delete(key)
  #(Hash-like)
  @keys.delete(key)
  @seqs.delete(key)
end
do_align(factory) click to toggle source

Performs multiple alignment by using external program.

# File lib/bio/alignment.rb, line 2070
def do_align(factory)
  a0 = self.class.new
  (0...self.size).each { |i| a0.store(i, self.order(i)) }
  r = factory.query(a0)
  a1 = r.alignment
  a0.keys.each do |k|
    unless a1[k.to_s] then
      raise 'alignment result is inconsistent with input data'
    end
  end
  a2 = self.new
  a0.keys.each do |k|
    a2.store(self.keys[k], a1[k.to_s])
  end
  a2
end
dup() click to toggle source

Duplicates the alignment

# File lib/bio/alignment.rb, line 1772
def dup
  #(Hash-like)
  self.new(self)
end
each() { |seqs| ... } click to toggle source

Iterates over each sequence. (Like Array#each)

# File lib/bio/alignment.rb, line 1731
def each
  #(Array-like)
  @keys.each do |k|
    yield @seqs[k]
  end
end
Also aliased as: each_seq
each_pair() { |k, seqs| ... } click to toggle source

Iterates over each key and sequence. (Like Hash#each_pair)

# File lib/bio/alignment.rb, line 1741
def each_pair
  #(Hash-like)
  @keys.each do |k|
    yield k, @seqs[k]
  end
end
each_seq()
Alias for: each
has_key?(key) click to toggle source

If the key exists, returns true. Otherwise, returns false. (Like Hash#has_key?)

# File lib/bio/alignment.rb, line 1724
def has_key?(key)
  #(Hash-like)
  @seqs.has_key?(key)
end
index(seq) click to toggle source

Returns the key for a given sequence. If not found, returns nil.

# File lib/bio/alignment.rb, line 1816
def index(seq)
  #(Hash-like)
  last_key = nil
  self.each_pair do |k, s|
    last_key = k
    if s.class == seq.class then
      r = (s == seq)
    else
      r = (s.to_s == seq.to_s)
    end
    break if r
  end
  last_key
end
isolate(*arg) click to toggle source

Sequences in the alignment are duplicated. If keys are given to the argument, sequences of given keys are duplicated.

It will be obsoleted.

# File lib/bio/alignment.rb, line 1836
def isolate(*arg)
  #(original)
  if arg.size == 0 then
    self.collect! do |s|
      seqclass.new(s)
    end
  else
    arg.each do |k|
      if self.has_key?(k) then
        s = self.delete(key)
        self.store(k, seqclass.new(s))
      end
    end
  end
  self
end
lstrip() click to toggle source

Not-destructive version of alignment_lstrip!. Returns a new alignment.

# File lib/bio/alignment.rb, line 1994
def lstrip
  #(String-like)
  na = self.dup
  na.isolate
  na.alignment_lstrip!
  na
end
merge(*other) click to toggle source

Merges given alignment and returns a new alignment.

# File lib/bio/alignment.rb, line 1782
def merge(*other)
  #(Hash-like)
  na = self.new(self)
  na.merge!(*other)
  na
end
merge!(*other) { |k, self, s| ... } click to toggle source

Merge given alignment. Note that it is destructive method.

# File lib/bio/alignment.rb, line 1791
def merge!(*other)
  #(Hash-like)
  if block_given? then
    other.each do |aln|
      aln.each_pair do |k, s|
        if self.has_key?(k) then
          s = yield k, self[k], s
          self.to_hash.store(k, s)
        else
          self.store(k, s)
        end
      end
    end
  else
    other.each do |aln|
      aln.each_pair do |k, s|
        self.delete(k) if self.has_key?(k)
        self.store(k, s)
      end
    end
  end
  self
end
normalize() click to toggle source

Not-destructive version of alignment_normalize!. Returns a new alignment.

# File lib/bio/alignment.rb, line 1975
def normalize
  #(original)
  na = self.dup
  na.alignment_normalize!
  na
end
number_of_sequences()
Alias for: size
order(n) click to toggle source

Gets the n-th sequence. If not found, returns nil.

# File lib/bio/alignment.rb, line 1681
def order(n)
  #(original)
  @seqs[@keys[n]]
end
purge(*arg) click to toggle source

Removes sequences from the alignment by given keys. Returns an alignment object consists of removed sequences.

It resembles BioPerl's AlignI::purge method.

# File lib/bio/alignment.rb, line 1926
def purge(*arg)
  #(BioPerl) AlignI::purge like method
  purged = self.new
  arg.each do |k|
    if self[k] then
      purged.store(k, self.delete(k))
    end
  end
  purged
end
rehash() click to toggle source

Reconstructs internal data structure. (Like Hash#rehash)

# File lib/bio/alignment.rb, line 1646
def rehash
  @seqs.rehash
  tmpkeys = @seqs.keys
  @keys.collect! do |k|
    tmpkeys.delete(k)
  end
  @keys.compact!
  @keys.concat(tmpkeys)
  self
end
remove_all_gaps() click to toggle source

Not-destructive version of remove_gaps!. Returns a new alignment.

The method name 'remove_gap' will be obsoleted. Please use 'remove_all_gaps' instead.

# File lib/bio/alignment.rb, line 2017
def remove_all_gaps
  #(original)
  na = self.dup
  na.isolate
  na.remove_all_gaps!
  na
end
remove_seq(seq) click to toggle source

Removes given sequence from the alignment. Returns removed sequence. If nothing removed, returns nil.

It resembles BioPerl's AlignI::remove_seq.

# File lib/bio/alignment.rb, line 1913
def remove_seq(seq)
  #(BioPerl) AlignI::remove_seq like method
  if k = self.index(seq) then
    self.delete(k)
  else
    nil
  end
end
replace_slice(aln, *arg) click to toggle source

Replace the specified region of the alignment to aln.

aln

String or Bio::Alignment object

arg

same format as String#slice

It will be obsoleted.

# File lib/bio/alignment.rb, line 2049
def replace_slice(aln, *arg)
  #(original)
  if aln.respond_to?(:to_str) then #aln.is_a?(String)
    self.each do |s|
      s[*arg] = aln
    end
  elsif aln.is_a?(self.class) then
    aln.each_pair do |k, s|
      self[k][*arg] = s
    end
  else
    i = 0
    aln.each do |s|
      self.order(i)[*arg] = s
      i += 1
    end
  end
  self
end
rstrip() click to toggle source

Not-destructive version of alignment_rstrip!. Returns a new alignment.

# File lib/bio/alignment.rb, line 1984
def rstrip
  #(String-like)
  na = self.dup
  na.isolate
  na.alignment_rstrip!
  na
end
select(*arg) { |s| ... } click to toggle source

If block is given, it acts like Array#select (Enumerable#select). Returns a new alignment containing all sequences of the alignment for which return value of given block is not false nor nil.

If no block is given, it acts like the BioPerl's AlignI::select. Returns a new alignment containing sequences of given keys.

The BioPerl's AlignI::select-like action will be obsoleted.

# File lib/bio/alignment.rb, line 1945
def select(*arg)
  #(original)
  na = self.new
  if block_given? then
    # 'arg' is ignored
    # nearly same action as Array#select (Enumerable#select)
    self.each_pair.each do |k, s|
      na.store(k, s) if yield(s)
    end
  else
    # BioPerl's AlignI::select like function
    arg.each do |k|
      if s = self[k] then
        na.store(k, s)
      end
    end
  end
  na
end
shift() click to toggle source

Removes the first sequence in the alignment and returns [ key, seq ].

# File lib/bio/alignment.rb, line 1669
def shift
  k = @keys.shift
  if k then
    s = @seqs.delete(k)
    [ k, s ]
  else
    nil
  end
end
size() click to toggle source

Number of sequences in the alignment.

# File lib/bio/alignment.rb, line 1716
def size
  #(Hash&Array-like)
  @seqs.size
end
Also aliased as: number_of_sequences
store(key, seq) click to toggle source

stores a sequence with key (name or definition of the sequence). Unlike __store__ method, the method doesn't allow same keys. If the key is already used, returns nil. When succeeded, returns key.

# File lib/bio/alignment.rb, line 1623
def store(key, seq)
  #(Hash-like) returns key instead of seq
  if @seqs.has_key?(key) then
    # don't allow same key
    # New key is discarded, while existing key is preserved.
    key = nil
  end
  unless key then
    unless defined?(@serial)
      @serial = 0
    end
    @serial = @seqs.size if @seqs.size > @serial
    while @seqs.has_key?(@serial)
      @serial += 1
    end
    key = @serial
  end
  self.__store__(key, seq)
  key
end
strip() click to toggle source

Not-destructive version of alignment_strip!. Returns a new alignment.

# File lib/bio/alignment.rb, line 2004
def strip
  #(String-like)
  na = self.dup
  na.isolate
  na.alignment_strip!
  na
end
to_fasta(*arg) click to toggle source

Converts to fasta format and returns a string.

The specification of the argument will be changed.

Note: to_fasta is deprecated. Please use output_fasta instead.

# File lib/bio/alignment.rb, line 2133
def to_fasta(*arg)
  #(original)
  warn "to_fasta is deprecated. Please use output_fasta."
  self.to_fasta_array(*arg).join('')
end
to_fasta_array(*arg) click to toggle source

Convert to fasta format and returns an array of strings.

It will be obsoleted.

# File lib/bio/alignment.rb, line 2090
def to_fasta_array(*arg)
  #(original)
  width = nil
  if arg[0].is_a?(Integer) then
    width = arg.shift
  end
  options = (arg.shift or {})
  width = options[:width] unless width
  if options[:avoid_same_name] then
    na = __clustal_avoid_same_name(self.keys, 30)
  else
    na = self.keys.collect { |k| k.to_s.gsub(/[\r\n\x00]/, ' ') }
  end
  a = self.collect do |s|
    ">#{na.shift}\n" +
      if width then
        s.to_s.gsub(Regexp.new(".{1,#{width}}"), "\\0\n")
      else
        s.to_s + "\n"
      end
  end
  a
end
to_fastaformat_array(*arg) click to toggle source

Convets to fasta format and returns an array of FastaFormat objects.

It will be obsoleted.

# File lib/bio/alignment.rb, line 2117
def to_fastaformat_array(*arg)
  #(original)
  require 'bio/db/fasta'
  a = self.to_fasta_array(*arg)
  a.collect! do |x|
    Bio::FastaFormat.new(x)
  end
  a
end
to_hash() click to toggle source

convert to hash

# File lib/bio/alignment.rb, line 1566
def to_hash
  #(Hash-like)
  @seqs
end
unshift(key, seq) click to toggle source

Prepends seq (with key) to the front of the alignment. (Like Array#unshift)

# File lib/bio/alignment.rb, line 1659
def unshift(key, seq)
  #(Array-like)
  self.store(key, seq)
  k = @keys.pop
  @keys.unshift(k)
  k
end
values() click to toggle source

Returns sequences. (Like Hash#values)

# File lib/bio/alignment.rb, line 1696
def values
  #(Hash-like)
  @keys.collect { |k| @seqs[k] }
end

Protected Instance Methods

new(*arg) click to toggle source

Creates new alignment. Internal use only.

# File lib/bio/alignment.rb, line 1764
def new(*arg)
  na = self.class.new(*arg)
  na.set_all_property(get_all_property)
  na
end