Class: Bio::Alignment::OriginalAlignment

Inherits:
Object
  • Object
show all
Includes:
HashExtension, OriginalPrivate, Enumerable
Defined in:
lib/bio/alignment.rb

Overview

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.

Constant Summary

Constants included from PropertyMethods

PropertyMethods::GAP_CHAR, PropertyMethods::GAP_REGEXP, PropertyMethods::MISSING_CHAR

Instance Attribute Summary collapse

Attributes included from PropertyMethods

#gap_char, #gap_regexp, #missing_char, #seqclass

Class Method Summary collapse

Instance Method Summary collapse

Methods included from OriginalPrivate

extract_key, extract_seq

Methods included from HashExtension

#alignment_concat, #sequence_names

Methods included from EnumerableExtension

#alignment_concat, #alignment_length, #alignment_lstrip!, #alignment_normalize!, #alignment_rstrip!, #alignment_site, #alignment_slice, #alignment_strip!, #alignment_subseq, #alignment_window, #collect_each_site, #consensus_each_site, #consensus_iupac, #consensus_string, #convert_match, #convert_unmatch, #each_site, #each_site_step, #each_window, #match_line, #match_line_amino, #match_line_nuc, #remove_all_gaps!, #seqclass, #sequence_names

Methods included from Output

#__output_phylip_common, #output, #output_clustal, #output_fasta, #output_molphy, #output_msf, #output_phylip, #output_phylipnon, #to_clustal

Methods included from PropertyMethods

#get_all_property, #is_gap?, #set_all_property

Constructor Details

#initialize(seqs = []) ⇒ OriginalAlignment

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.



1553
1554
1555
1556
1557
 
# File 'lib/bio/alignment.rb', line 1553

def initialize(seqs = [])
  @seqs = {}
  @keys = []
  self.add_sequences(seqs)
end

Instance Attribute Details

#keys ⇒ Object (readonly)

identifiers (or definitions or names) of the sequences



1609
1610
1611
 
# File 'lib/bio/alignment.rb', line 1609

def keys
  @keys
end

Class Method Details

.new2(*arg) ⇒ Object

Creates a new alignment object from given arguments.

It will be obsoleted.



1544
1545
1546
 
# File 'lib/bio/alignment.rb', line 1544

def self.new2(*arg)
  self.new(arg)
end

.readfiles(*files) ⇒ Object

Read files and creates a new alignment object.

It will be obsoleted.



1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
 
# File 'lib/bio/alignment.rb', line 1530

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

Instance Method Details

#<<(seq) ⇒ Object

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



1709
1710
1711
1712
1713
 
# File 'lib/bio/alignment.rb', line 1709

def <<(seq)
  #(Array-like)
  self.store(nil, seq)
  self
end

#==(x) ⇒ Object

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



1561
1562
1563
1564
1565
1566
1567
1568
 
# File 'lib/bio/alignment.rb', line 1561

def ==(x)
  #(original)
  if x.is_a?(self.class)
    self.to_hash == x.to_hash
  else
    false
  end
end

#[](*arg) ⇒ Object

Gets a sequence. (Like Hash#[])



1716
1717
1718
1719
 
# File 'lib/bio/alignment.rb', line 1716

def [](*arg)
  #(Hash-like)
  @seqs[*arg]
end

#__store__(key, seq) ⇒ Object

stores a sequences with the name

key

name of the sequence

seq

sequence



1614
1615
1616
1617
1618
1619
1620
 
# File 'lib/bio/alignment.rb', line 1614

def __store__(key, seq)
  #(Hash-like)
  h = { key => seq }
  @keys << h.keys[0]
  @seqs.update(h)
  seq
end

#add_seq(seq, key = nil) ⇒ Object

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.



1905
1906
1907
1908
1909
1910
1911
1912
1913
 
# File 'lib/bio/alignment.rb', line 1905

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) ⇒ Object

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.



1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
 
# File 'lib/bio/alignment.rb', line 1581

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 ⇒ Object Also known as: collect_align

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.



1864
1865
1866
1867
1868
1869
1870
1871
1872
 
# File 'lib/bio/alignment.rb', line 1864

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

#collect! ⇒ Object

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



1756
1757
1758
1759
1760
1761
 
# File 'lib/bio/alignment.rb', line 1756

def collect!
  #(Array-like)
  @keys.each do |k|
    @seqs[k] = yield @seqs[k]
  end
end

#compact ⇒ Object

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



1893
1894
1895
1896
1897
1898
 
# File 'lib/bio/alignment.rb', line 1893

def compact
  #(Array-like)
  na = self.dup
  na.compact!
  na
end

#compact! ⇒ Object

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



1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
 
# File 'lib/bio/alignment.rb', line 1877

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) ⇒ Object

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.



2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
 
# File 'lib/bio/alignment.rb', line 2038

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) ⇒ Object

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



1695
1696
1697
1698
1699
 
# File 'lib/bio/alignment.rb', line 1695

def delete(key)
  #(Hash-like)
  @keys.delete(key)
  @seqs.delete(key)
end

#do_align(factory) ⇒ Object

Performs multiple alignment by using external program.



2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
 
# File 'lib/bio/alignment.rb', line 2076

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 ⇒ Object

Duplicates the alignment



1778
1779
1780
1781
 
# File 'lib/bio/alignment.rb', line 1778

def dup
  #(Hash-like)
  self.new(self)
end

#each ⇒ Object Also known as: each_seq

Iterates over each sequence. (Like Array#each)



1737
1738
1739
1740
1741
1742
 
# File 'lib/bio/alignment.rb', line 1737

def each
  #(Array-like)
  @keys.each do |k|
    yield @seqs[k]
  end
end

#each_pair ⇒ Object

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



1747
1748
1749
1750
1751
1752
 
# File 'lib/bio/alignment.rb', line 1747

def each_pair
  #(Hash-like)
  @keys.each do |k|
    yield k, @seqs[k]
  end
end

#has_key?(key) ⇒ Boolean

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

Returns:

  • (Boolean) 


1730
1731
1732
1733
 
# File 'lib/bio/alignment.rb', line 1730

def has_key?(key)
  #(Hash-like)
  @seqs.has_key?(key)
end

#index(seq) ⇒ Object

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



1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
 
# File 'lib/bio/alignment.rb', line 1822

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) ⇒ Object

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

It will be obsoleted.



1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
 
# File 'lib/bio/alignment.rb', line 1842

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 ⇒ Object

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



2000
2001
2002
2003
2004
2005
2006
 
# File 'lib/bio/alignment.rb', line 2000

def lstrip
  #(String-like)
  na = self.dup
  na.isolate
  na.alignment_lstrip!
  na
end

#merge(*other) ⇒ Object

Merges given alignment and returns a new alignment.



1788
1789
1790
1791
1792
1793
 
# File 'lib/bio/alignment.rb', line 1788

def merge(*other)
  #(Hash-like)
  na = self.new(self)
  na.merge!(*other)
  na
end

#merge!(*other) ⇒ Object

Merge given alignment. Note that it is destructive method.



1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
 
# File 'lib/bio/alignment.rb', line 1797

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 ⇒ Object

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



1981
1982
1983
1984
1985
1986
 
# File 'lib/bio/alignment.rb', line 1981

def normalize
  #(original)
  na = self.dup
  na.alignment_normalize!
  na
end

#order(n) ⇒ Object

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



1687
1688
1689
1690
 
# File 'lib/bio/alignment.rb', line 1687

def order(n)
  #(original)
  @seqs[@keys[n]]
end

#purge(*arg) ⇒ Object

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

It resembles BioPerl’s AlignI::purge method.



1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
 
# File 'lib/bio/alignment.rb', line 1932

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 ⇒ Object

Reconstructs internal data structure. (Like Hash#rehash)



1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
 
# File 'lib/bio/alignment.rb', line 1651

def rehash
  @seqs.rehash
  oldkeys = @keys
  tmpkeys = @seqs.keys
  @keys.collect! do |k|
    tmpkeys.delete(k)
  end
  @keys.compact!
  @keys.concat(tmpkeys)
  self
end

#remove_all_gaps ⇒ Object

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

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



2023
2024
2025
2026
2027
2028
2029
 
# File 'lib/bio/alignment.rb', line 2023

def remove_all_gaps
  #(original)
  na = self.dup
  na.isolate
  na.remove_all_gaps!
  na
end

#remove_seq(seq) ⇒ Object

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

It resembles BioPerl’s AlignI::remove_seq.



1919
1920
1921
1922
1923
1924
1925
1926
 
# File 'lib/bio/alignment.rb', line 1919

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) ⇒ Object

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.



2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
 
# File 'lib/bio/alignment.rb', line 2055

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 ⇒ Object

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



1990
1991
1992
1993
1994
1995
1996
 
# File 'lib/bio/alignment.rb', line 1990

def rstrip
  #(String-like)
  na = self.dup
  na.isolate
  na.alignment_rstrip!
  na
end

#select(*arg) ⇒ Object

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.



1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
 
# File 'lib/bio/alignment.rb', line 1951

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 ⇒ Object

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



1675
1676
1677
1678
1679
1680
1681
1682
1683
 
# File 'lib/bio/alignment.rb', line 1675

def shift
  k = @keys.shift
  if k then
    s = @seqs.delete(k)
    [ k, s ]
  else
    nil
  end
end

#size ⇒ Object Also known as: number_of_sequences

Number of sequences in the alignment.



1722
1723
1724
1725
 
# File 'lib/bio/alignment.rb', line 1722

def size
  #(Hash&Array-like)
  @seqs.size
end

#store(key, seq) ⇒ Object

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.



1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
 
# File 'lib/bio/alignment.rb', line 1628

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 ⇒ Object

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



2010
2011
2012
2013
2014
2015
2016
 
# File 'lib/bio/alignment.rb', line 2010

def strip
  #(String-like)
  na = self.dup
  na.isolate
  na.alignment_strip!
  na
end

#to_fasta(*arg) ⇒ Object

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.



2139
2140
2141
2142
2143
 
# File 'lib/bio/alignment.rb', line 2139

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) ⇒ Object

Convert to fasta format and returns an array of strings.

It will be obsoleted.



2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
 
# File 'lib/bio/alignment.rb', line 2096

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) ⇒ Object

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

It will be obsoleted.



2123
2124
2125
2126
2127
2128
2129
2130
2131
 
# File 'lib/bio/alignment.rb', line 2123

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 ⇒ Object

convert to hash



1571
1572
1573
1574
 
# File 'lib/bio/alignment.rb', line 1571

def to_hash
  #(Hash-like)
  @seqs
end

#unshift(key, seq) ⇒ Object

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



1665
1666
1667
1668
1669
1670
1671
 
# File 'lib/bio/alignment.rb', line 1665

def unshift(key, seq)
  #(Array-like)
  self.store(key, seq)
  k = @keys.pop
  @keys.unshift(k)
  k
end

#values ⇒ Object

Returns sequences. (Like Hash#values)



1702
1703
1704
1705
 
# File 'lib/bio/alignment.rb', line 1702

def values
  #(Hash-like)
  @keys.collect { |k| @seqs[k] }
end