bio-alignment 0.0.5 → 0.0.6

data/lib/bio-alignment/columns.rb

@@ -0,0 +1,102 @@
+require 'bio-alignment/state'
+
+module Bio
+ 
+  module BioAlignment
+
+    # The Columns module provides accessors for the column list
+    # returning Column objects
+    module Columns
+     
+      # Return a list of Column objects. The contents of the  
+      # columns are accessed lazily
+      def columns
+        @columns ||= (0..num_columns-1).map { | col | Column.new(self,col) }
+      end
+
+      # def columns= list
+      #   @columns = list
+      # end
+
+      def num_columns
+        rows.first.length
+      end
+
+      # Return an alignment which match columns. The originating
+      # sequences should have methods 'empty_copy' and '<<'
+      def columns_where &block
+        seqs = []
+        rows.each do | seq | 
+          new_seq = seq.empty_copy
+          seq.each_with_index do | e,i |
+            new_seq << e if block.call(columns[i])
+          end
+          seqs << new_seq
+        end
+        Alignment.new(seqs)
+      end
+
+      def columns_to_s
+        columns.map { |c| (c.state ? c.state.to_s : '?') }.join
+      end
+       
+      def clone_columns!
+        # clone the columns
+        old_columns = @columns
+        @columns = []
+        old_columns.each do | old_column |
+          @columns << old_column.clone
+        end
+      end
+    end
+
+    # Support the notion of columns in an alignment. A column
+    # can have state by attaching state objects
+    class Column
+      include State
+      include Enumerable
+
+      def initialize aln, col
+        @aln = aln
+        @col = col
+      end
+
+      def [] index
+        @aln[index][@col] 
+      end
+
+      # iterator fetches a column on demand, yielding column elements
+      def each
+        @aln.each do | seq |
+          yield seq[@col]
+        end
+      end
+
+      def length
+        @length ||= @aln.rows.size
+      end
+
+      def count &block
+        counter = 0
+        each do | e |
+          found = 
+            if e.kind_of?(String)
+              block.call(Element.new(e))
+            else
+              block.call(e)
+            end
+          counter += 1 if found
+        end
+        counter
+      end
+
+      def to_s
+        map{|e| e.to_s}.join('')
+      end
+
+    end
+
+  end
+
+end
+

data/lib/bio-alignment/edit/del_bridges.rb

@@ -1,10 +1,27 @@
+require 'bio-alignment/edit/edit_columns'
 
 module Bio
   module BioAlignment
 
     module DelBridges
+      include MarkColumns
    
-      def clean
+      # Return a new alignment with columns marked for deletion, i.e. mark
+      # columns that mostly contain gaps (threshold +percentage+). The 
+      # alignment returned is a cloned copy
+      def mark_bridges percentage = 30
+        mark_columns { |state,column| 
+          num = column.count { |e| e.gap? or e.undefined? }
+          if (num.to_f/column.length) > 1.0-percentage/100.0
+            state.delete!
+          end
+          state
+        }
+      end
+
+      # Return an alignment with the bridges removed
+      def del_bridges percentage=30
+        mark_bridges.columns_where { |col| !col.state.deleted? }
       end
     end
   end

data/lib/bio-alignment/edit/del_non_informative_sequences.rb

@@ -0,0 +1,27 @@
+require 'bio-alignment/edit/edit_rows'
+
+module Bio
+  module BioAlignment
+
+    module DelNonInformativeSequences
+      include MarkRows
+   
+      # Return a new alignment with rows marked for deletion, i.e. mark rows
+      # that mostly contain undefined elements and gaps (threshold
+      # +percentage+). The alignment returned is a cloned copy
+      def mark_non_informative_sequences percentage = 30
+        mark_rows { |state,row| 
+          num = row.count { |e| e.gap? or e.undefined? }
+          if (num.to_f/row.length) > 1.0-percentage/100.0
+            state.delete!
+          end
+          state
+        }
+      end
+
+      def del_non_informative_sequences percentage=30
+        mark_non_informative_sequences.rows_where { |row| !row.state.deleted? }
+      end
+    end
+  end
+end

data/lib/bio-alignment/edit/del_short_sequences.rb

@@ -0,0 +1,28 @@
+require 'bio-alignment/edit/edit_rows'
+
+module Bio
+  module BioAlignment
+
+    module DelShortSequences
+      include MarkRows
+   
+      # Return a new alignment with rows marked for deletion, i.e. mark
+      # rows that mostly contain gaps (threshold +percentage+). The 
+      # alignment returned is a cloned copy
+      def mark_short_sequences percentage = 30
+        mark_rows { |state,row| 
+          num = row.count { |e| e.gap? }
+          if (num.to_f/row.length) > 1.0-percentage/100.0
+            state.delete!
+          end
+          state
+        }
+      end
+
+      # Return an alignment with the bridges removed
+      def del_short_sequences percentage=30
+        mark_short_sequences.rows_where { |row| !row.state.deleted? }
+      end
+    end
+  end
+end

data/lib/bio-alignment/edit/edit_columns.rb

@@ -0,0 +1,22 @@
+module Bio
+  module BioAlignment
+
+    module MarkColumns
+      def mark_columns &block
+        aln = self.clone 
+        # clone column state
+        aln.columns.each do | column |
+          new_state =
+            if column.state
+              column.state.clone
+            else
+              ColumnState.new
+            end
+          column.state = block.call(new_state,column)
+        end
+        aln
+      end
+    end
+  end
+end
+

data/lib/bio-alignment/edit/edit_rows.rb

@@ -0,0 +1,49 @@
+module Bio
+  module BioAlignment
+
+    # Function for marking rows (sequences), when a row block returns the new
+    # state, and returning a newly cloned alignment
+    module MarkRows
+
+      # Mark each seq
+      def mark_rows &block
+        aln = markrows_clone
+        aln.rows.each do | row |
+          row.state = block.call(row.state,row)
+        end
+        aln
+      end
+
+      # allow the marking of elements in a copied alignment, making sure 
+      # each element is a proper Element object that can contain state.
+      # A Sequence alignment will be turned into an Elements alignment.
+      def mark_row_elements &block
+        aln = markrows_clone
+        aln.rows.each_with_index do | row,rownum |
+          new_seq = block.call(row.to_elements,rownum)
+          aln.rows[rownum] = new_seq
+        end
+        aln
+      end
+
+    protected 
+
+      def markrows_clone
+        aln = self.clone 
+        # clone row state, or add a state object 
+        aln.rows.each do | row |
+          new_state =
+            if row.state
+              row.state.clone
+            else
+              RowState.new
+            end
+          row.state = new_state
+        end
+        aln
+      end
+
+    end
+  end
+end
+

data/lib/bio-alignment/edit/mask_islands.rb

@@ -0,0 +1,115 @@
+require 'bio-alignment/edit/edit_rows'
+
+module Bio
+  module BioAlignment
+
+    module MaskIslands
+      include MarkRows
+
+      class IslandElementState < ElementMaskedState
+        attr_accessor :unique
+        def to_s
+          super + (@unique?'U':' ')
+        end
+      end
+
+      # Drop all 'islands' in a sequence with low consensus, that show a gap
+      # larger than 'min_gap_size' (default 3) on both sides, and are shorter
+      # than 'max_island_size' (default 30). An island larger than 30 elements
+      # is arguably no longer an island, and low consensus stretches may be
+      # loops - it is up to the alignment procedure to get that right. We also
+      # allow for micro deletions inside an alignment (1 or 2 elements).
+      # The island consensus is calculated by column. If more than 50% of the
+      # island shows consensus, the island is retained. Consensus for each
+      # element is defined as the number of matches in the column (default 1).
+      def mark_islands
+        mark_row_elements { |row,rownum|
+          # first set state and find unique elements (i.e. consensus)
+          row.each_with_index do |e,colnum|
+            e.state = IslandElementState.new
+            column = columns[colnum]
+            e.state.unique = (column.count{|e2| !e2.gap? and e2 == e } == 1)
+            # p [e,e.state,e.state.unique]
+          end
+          # group elements into islands (split on gap) and mask
+          gap = []
+          island = []
+          in_island = true
+          row.each do |e|
+            if not in_island
+              if e.gap?
+                gap << e
+              else
+                island << e
+                in_island = true
+                gap = []
+              end
+            else # in_island
+              if not e.gap?
+                island << e
+                gap = []
+              else
+                gap << e
+                if gap.length > 2
+                  in_island = false
+                  mark_island(island)
+                  # print_island(island)
+                  island = []
+                end
+              end
+            end
+          end
+          if in_island
+            mark_island(island)
+            # print_island(island) if island.length > 0
+          end
+          # row.each_with_index do |e,colnum|
+          #   e.state = ElementState.new
+          #   column = columns[colnum]
+          #   e.state.mask! if column.count{|e2| !e2.gap? and e2 == e } == 1
+          #   # print e,',',e.state,';'
+          # end
+          # now make sure there are at least 5 in a row, otherwise
+          # start unmasking. First group all elements
+          # group = []
+          # row.each_with_index do |e,colnum|
+          #   next if e.gap?
+          #   if e.state.masked?
+          #     group << e
+          #   else
+          #     if group.length <= min_serial
+          #       # the group is too small
+          #       group.each do | e2 |
+          #         e2.state.unmask!
+          #       end
+          #     end
+          #     group = []
+          #   end
+          # end
+          row  # return changed sequence
+        }
+      end
+
+    private
+
+      def mark_island island
+        return if island.length < 2
+        unique = 0
+        island.each do |e|
+          unique += 1 if e.state.unique == true
+        end
+        consensus = 1.0 - unique.to_f / island.length
+        # p unique, consensus
+        if consensus < 0.5
+          island.each do |e|
+            e.state.mask!
+          end
+        end
+      end
+
+      def print_island island
+        p island.map {|e2| e2.to_s + ':' + e2.state.to_s }.join(",")
+      end
+    end
+  end
+end

data/lib/bio-alignment/edit/mask_serial_mutations.rb

@@ -0,0 +1,44 @@
+require 'bio-alignment/edit/edit_rows'
+
+module Bio
+  module BioAlignment
+
+    module MaskSerialMutations
+      include MarkRows
+
+      # edit copied alignment and mark elements if they are a continuous of
+      # unique mutations in the alignment. The default is at least 5 mutations
+      # in a row.
+      def mark_serial_mutations min_serial=5
+        mark_row_elements { |row,rownum| 
+          # if an element is unique, mask it
+          row.each_with_index do |e,colnum|
+            e.state = ElementMaskedState.new
+            column = columns[colnum]
+            e.state.mask! if column.count{|e2| !e2.gap? and e2 == e } == 1
+            # print e,',',e.state,';'
+          end
+          # now make sure there are at least 5 in a row, otherwise
+          # start unmasking. First group all elements
+          group = []
+          row.each_with_index do |e,colnum|
+            next if e.gap?
+            if e.state.masked?
+              group << e
+            else
+              if group.length <= min_serial
+                # the group is too small
+                group.each do | e2 |
+                  e2.state.unmask!
+                end
+              end
+              group = []
+            end
+          end
+          row  # return changed sequence
+        }
+      end
+
+    end
+  end
+end

data/lib/bio-alignment/elements.rb

@@ -0,0 +1,86 @@
+
+module Bio
+  module BioAlignment
+
+    # Simple element that can be queried
+    class Element
+      GAP = '-'
+      UNDEFINED = 'X'
+      include State
+
+      def initialize c
+        @c = c
+      end
+      def gap?
+        @c == GAP
+      end
+      def undefined?
+        @c == 'X'
+      end
+      def to_s
+        @c
+      end
+      def == other
+        to_s == other.to_s
+      end
+    end
+
+    # Elements is a container for Element sequences. 
+    #
+    class Elements
+      include Enumerable
+      include State
+
+      attr_reader :id, :seq
+      def initialize id, seq
+        @id = id
+        @seq = []
+        if seq.kind_of?(Elements)
+          @seq = seq.clone
+        elsif seq.kind_of?(String)
+          seq.each_char do |c|
+            @seq << Element.new(c)
+          end
+        else
+          seq.each do |s|
+            @seq << Element.new(s)
+          end
+        end
+      end
+
+      def [] index
+        @seq[index]
+      end
+
+      def length
+        @seq.length
+      end
+
+      def each
+        @seq.each { |e| yield e }
+      end
+
+      def to_s
+        @seq.map{|e| e.to_s }.join("")
+      end
+
+      def << element
+        @seq << element
+      end
+
+      def empty_copy
+        Elements.new(@id,"")
+      end
+
+      def clone
+        copy = Elements.new(@id,"")
+        @seq.each do |e|
+          copy << e.dup
+        end
+        copy
+      end
+
+    end
+  end
+
+end