BioDSL 1.0.0

data/lib/BioDSL/seq/backtrack.rb

@@ -0,0 +1,252 @@
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                                #
+# Copyright (C) 2007-2015 Martin Asser Hansen (mail@maasha.dk).                  #
+#                                                                                #
+# This program is free software; you can redistribute it and/or                  #
+# modify it under the terms of the GNU General Public License                    #
+# as published by the Free Software Foundation; either version 2                 #
+# of the License, or (at your option) any later version.                         #
+#                                                                                #
+# This program is distributed in the hope that it will be useful,                #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of                 #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                  #
+# GNU General Public License for more details.                                   #
+#                                                                                #
+# You should have received a copy of the GNU General Public License              #
+# along with this program; if not, write to the Free Software                    #
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. #
+#                                                                                #
+# http://www.gnu.org/copyleft/gpl.html                                           #
+#                                                                                #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                                #
+# This software is part of BioDSL (www.BioDSL.org).                        #
+#                                                                                #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+
+module BioDSL
+  # Error class for all exceptions to do with BackTrack.
+  class BackTrackError < StandardError; end
+
+  # Module containing code to locate nucleotide patterns in sequences allowing for
+  # ambiguity codes and a given maximum mismatches, insertions, and deletions. The
+  # pattern match engine is based on a backtrack algorithm.
+  # Insertions are nucleotides found in the pattern but not in the sequence.
+  # Deletions are nucleotides found in the sequence but not in the pattern.
+  # Algorithm based on code kindly provided by j_random_hacker @ Stackoverflow:
+  # http://stackoverflow.com/questions/7557017/approximate-string-matching-using-backtracking/
+  module BackTrack
+    extend BioDSL::Ambiguity
+
+    OK_PATTERN = Regexp.new('^[bflsycwphqrimtnkvadegu]+$')
+    MAX_MIS    = 5 # Maximum number of mismatches allowed
+    MAX_INS    = 5 # Maximum number of insertions allowed
+    MAX_DEL    = 5 # Maximum number of deletions allowed
+
+    # ------------------------------------------------------------------------------
+    #   str.patmatch(pattern[, options])
+    #   -> Match
+    #   str.patmatch(pattern[, options]) { |match|
+    #     block
+    #   }
+    #   -> Match
+    #
+    #   options:
+    #     :start
+    #     :stop
+    #     :max_mismatches
+    #     :max_insertions
+    #     :max_deletions
+    #
+    # ------------------------------------------------------------------------------
+    # Method to iterate through a sequence from a given start position to the end of
+    # the sequence or to a given stop position to locate a pattern allowing for a
+    # maximum number of mismatches, insertions, and deletions. Insertions are
+    # nucleotides found in the pattern but not in the sequence. Deletions are
+    # nucleotides found in the sequence but not in the pattern.
+    def patmatch(pattern, options = {})
+      options[:start]          ||= 0
+      options[:stop]           ||= self.length - 1
+      options[:max_mismatches] ||= 0
+      options[:max_insertions] ||= 0
+      options[:max_deletions]  ||= 0
+
+      self.patscan(pattern, options) do |m|
+        if block_given?
+          yield m
+        else
+          return m
+        end
+      end
+    end
+
+    # ------------------------------------------------------------------------------
+    #   str.patscan(pattern[, options])
+    #   -> Array
+    #   str.patscan(pattern[, options]) { |match|
+    #     block
+    #   }
+    #   -> Match
+    #
+    #   options:
+    #     :start
+    #     :stop
+    #     :max_mismatches
+    #     :max_insertions
+    #     :max_deletions
+    #
+    # ------------------------------------------------------------------------------
+    # Method to iterate through a sequence from a given start position to the end of
+    # the sequence or to a given stop position to locate a pattern allowing for a
+    # maximum number of mismatches, insertions, and deletions. Insertions are
+    # nucleotides found in the pattern but not in the sequence. Deletions are
+    # nucleotides found in the sequence but not in the pattern. Matches found in
+    # block context return the Match object. Otherwise matches are returned in an
+    # Array of Match objects.
+    def patscan(pattern, options = {})
+      options[:start]          ||= 0
+      options[:stop]           ||= self.length - 1
+      options[:max_mismatches] ||= 0
+      options[:max_insertions] ||= 0
+      options[:max_deletions]  ||= 0
+
+      raise BackTrackError, "Bad pattern: #{pattern}"                                          unless pattern.downcase =~ OK_PATTERN
+      raise BackTrackError, "start: #{options[:start]} out of range (0 .. #{self.length - 1})"           unless (0 ... self.length).include? options[:start]
+      raise BackTrackError, "stop: #{options[:stop]} out of range (0 .. #{self.length - 1})"             unless (0 ... self.length).include? options[:stop]
+      raise BackTrackError, "max_mismatches: #{options[:max_mismatches]} out of range (0 .. #{MAX_MIS})" unless (0 .. MAX_MIS).include? options[:max_mismatches]
+      raise BackTrackError, "max_insertions: #{options[:max_insertions]} out of range (0 .. #{MAX_INS})" unless (0 .. MAX_INS).include? options[:max_insertions]
+      raise BackTrackError, "max_deletions: #{options[:max_deletions]} out of range (0 .. #{MAX_DEL})"   unless (0 .. MAX_DEL).include? options[:max_deletions]
+
+      matches = []
+
+      while result = scan_C(self.seq,
+                            pattern,
+                            options[:start],
+                            options[:stop],
+                            options[:max_mismatches],
+                            options[:max_insertions],
+                            options[:max_deletions]
+                           )
+        match = Match.new(result.first, result.last, self.seq[result.first ... result.first + result.last])
+
+        if block_given?
+          yield match
+        else
+          matches << match
+        end
+
+        options[:start] = result.first + 1
+      end
+
+      return matches unless block_given?
+    end
+
+    private
+
+    inline do |builder|
+      add_ambiguity_macro(builder)
+
+      # Backtrack algorithm for matching a pattern (p) starting in a sequence (s) allowing for mis
+      # mismatches, ins insertions and del deletions. ss is the start of the sequence, used only for
+      # reporting the match endpoints. State is used to avoid ins followed by del and visa versa which
+      # are nonsense.
+      builder.prefix %{
+        unsigned int backtrack(
+          char         *ss,     // Sequence start
+          char         *s,      // Sequence
+          char         *p,      // Pattern
+          unsigned int  mis,    // Max mismatches
+          unsigned int  ins,    // Max insertions
+          unsigned int  del,    // Max deletions
+          int           state   // Last event: mis, ins or del
+        )
+        {
+          unsigned int r = 0;
+
+          while (*s && MATCH(*s, *p)) ++s, ++p;    // OK to always match longest segment
+
+          if (!*p)
+            return (unsigned int) (s - ss);
+          else
+          {
+            if (mis && *s && *p &&            (r = backtrack(ss, s + 1, p + 1, mis - 1, ins, del, 0))) return r;
+            if (ins && *p && (state != -1) && (r = backtrack(ss, s, p + 1, mis, ins - 1, del, 1)))     return r;
+            if (del && *s && (state != 1)  && (r = backtrack(ss, s + 1, p, mis, ins, del - 1, -1)))    return r;
+          }
+
+          return 0;
+        }
+      }
+   
+      # Find pattern (p) in a sequence (s) starting at pos, with at most mis mismatches, ins
+      # insertions and del deletions.
+      builder.c %{
+        VALUE scan_C(
+          VALUE _s,       // Sequence
+          VALUE _p,       // Pattern
+          VALUE _start,   // Search postition start
+          VALUE _stop,    // Search position stop
+          VALUE _mis,     // Maximum mismatches
+          VALUE _ins,     // Maximum insertions
+          VALUE _del      // Maximum deletions
+        )
+        {
+          char         *s     = StringValuePtr(_s);
+          char         *p     = StringValuePtr(_p);
+          unsigned int  start = FIX2UINT(_start);
+          unsigned int  stop  = FIX2UINT(_stop);
+          unsigned int  mis   = FIX2UINT(_mis);
+          unsigned int  ins   = FIX2UINT(_ins);
+          unsigned int  del   = FIX2UINT(_del);
+
+          char         *ss    = s;
+          int           state = 0;
+          unsigned int  i     = 0;
+          unsigned int  e     = 0;
+          VALUE         tuple;
+
+          s += start;
+
+          for (i = start; i <= stop; i++, s++)
+          {
+            if ((e = backtrack(ss, s, p, mis, ins, del, state)))
+            {
+              tuple = rb_ary_new();
+              rb_ary_push(tuple, INT2FIX((int) (s - ss)));
+              rb_ary_push(tuple, INT2FIX((int) e - (s - ss)));
+              return tuple;
+            }
+          }
+
+          return Qnil;
+        }
+      }
+    end
+
+    # Class containing match information.
+    class Match
+      attr_reader :pos, :length, :match
+
+      def initialize(pos, length, match)
+        @pos    = pos
+        @length = length
+        @match  = match
+      end
+
+      def start
+        @pos
+      end
+
+      def stop
+        @pos + @length - 1
+      end
+
+      def to_s
+        "#{pos}:#{length}:#{match}"
+      end
+    end
+  end
+end
+
+
+__END__

data/lib/BioDSL/seq/digest.rb

@@ -0,0 +1,99 @@
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# Copyright (C) 2007-2015 Martin Asser Hansen (mail@maasha.dk).                #
+#                                                                              #
+# This program is free software; you can redistribute it and/or                #
+# modify it under the terms of the GNU General Public License                  #
+# as published by the Free Software Foundation; either version 2               #
+# of the License, or (at your option) any later version.                       #
+#                                                                              #
+# This program is distributed in the hope that it will be useful,              #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                #
+# GNU General Public License for more details.                                 #
+#                                                                              #
+# You should have received a copy of the GNU General Public License            #
+# along with this program; if not, write to the Free Software                  #
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,    #
+# USA.                                                                         #
+#                                                                              #
+# http://www.gnu.org/copyleft/gpl.html                                         #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# This software is part of BioDSL (www.github.com/maasha/BioDSL).              #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+
+# Namespace for BioDSL.
+module BioDSL
+  # Error class for all exceptions to do with Digest.
+  DigestError = Class.new(StandardError)
+
+  # Namespace for Digest.
+  module Digest
+    # Method to get the next digestion product from a sequence.
+    def each_digest(pattern, cut_pos)
+      return to_enum(:each_digest, pattern, cut_pos) unless block_given?
+      pattern = disambiguate(pattern)
+      offset  = 0
+
+      seq.upcase.scan pattern do
+        pos = $`.length + cut_pos
+
+        if pos >= 0 && pos < length - 2
+          subseq = self[offset...pos]
+          subseq.seq_name = "#{seq_name}[#{offset}-#{pos - offset - 1}]"
+
+          yield subseq
+        end
+
+        offset = pos
+      end
+
+      offset = 0 if offset < 0 || offset > length
+      subseq = self[offset..-1]
+      subseq.seq_name = "#{seq_name}[#{offset}-#{length - 1}]"
+
+      yield subseq
+    end
+
+    private
+
+    # Method that returns a regexp object with a restriction
+    # enzyme pattern with ambiguity codes substituted to the
+    # appropriate regexp.
+    def disambiguate(pattern)
+      ambiguity = {
+        'A' => 'A',
+        'T' => 'T',
+        'U' => 'T',
+        'C' => 'C',
+        'G' => 'G',
+        'M' => '[AC]',
+        'R' => '[AG]',
+        'W' => '[AT]',
+        'S' => '[CG]',
+        'Y' => '[CT]',
+        'K' => '[GT]',
+        'V' => '[ACG]',
+        'H' => '[ACT]',
+        'D' => '[AGT]',
+        'B' => '[CGT]',
+        'N' => '[GATC]'
+      }
+
+      new_pattern = ''
+
+      pattern.upcase.each_char do |char|
+        if ambiguity[char]
+          new_pattern << ambiguity[char]
+        else
+          fail DigestError, "Could not disambiguate residue: #{char}"
+        end
+      end
+
+      Regexp.new(new_pattern)
+    end
+  end
+end

data/lib/BioDSL/seq/dynamic.rb

@@ -0,0 +1,263 @@
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                                #
+# Copyright (C) 2007-2015 Martin Asser Hansen (mail@maasha.dk).                  #
+#                                                                                #
+# This program is free software; you can redistribute it and/or                  #
+# modify it under the terms of the GNU General Public License                    #
+# as published by the Free Software Foundation; either version 2                 #
+# of the License, or (at your option) any later version.                         #
+#                                                                                #
+# This program is distributed in the hope that it will be useful,                #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of                 #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                  #
+# GNU General Public License for more details.                                   #
+#                                                                                #
+# You should have received a copy of the GNU General Public License              #
+# along with this program; if not, write to the Free Software                    #
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. #
+#                                                                                #
+# http://www.gnu.org/copyleft/gpl.html                                           #
+#                                                                                #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                                #
+# This software is part of BioDSL (www.BioDSL.org).                        #
+#                                                                                #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+
+module BioDSL
+  # Error class for Dynamic.
+  class DynamicError < StandardError; end
+
+  # Module containing code to locate nucleotide patterns in sequences allowing for
+  # ambiguity codes and a given maximum edit distance.
+  # Insertions are nucleotides found in the pattern but not in the sequence.
+  # Deletions are nucleotides found in the sequence but not in the pattern.
+  #
+  # Inspired by the paper by Bruno Woltzenlogel Paleo (page 197):
+  # http://www.logic.at/people/bruno/Papers/2007-GATE-ESSLLI.pdf
+  module Dynamic
+    extend BioDSL::Ambiguity
+
+    # ------------------------------------------------------------------------------
+    #   str.patmatch(pattern[, pos[, max_edit_distance]])
+    #   -> Match or nil
+    #   str.patscan(pattern[, pos[, max_edit_distance]]) { |match|
+    #     block
+    #   }
+    #   -> Match
+    #
+    # ------------------------------------------------------------------------------
+    # Method to iterate through a sequence to locate the first pattern match
+    # starting from a given position and allowing for a maximum edit distance.
+    def patmatch(pattern, pos = 0, max_edit_distance = 0)
+      self.patscan(pattern, pos, max_edit_distance) do |m|
+        return m
+      end
+    end
+
+    # ------------------------------------------------------------------------------
+    #   str.patscan(pattern[, pos[, max_edit_distance]])
+    #   -> Array or nil
+    #   str.patscan(pattern[, pos[, max_edit_distance]]) { |match|
+    #     block
+    #   }
+    #   -> Match
+    #
+    # ------------------------------------------------------------------------------
+    # Method to iterate through a sequence to locate pattern matches starting from a
+    # given position and allowing for a maximum edit distance. Matches found in
+    # block context return the Match object. Otherwise matches are returned in an
+    # Array.
+    def patscan(pattern, pos = 0, max_edit_distance = 0)
+      matches = []
+
+      while result = match_C(self.seq, self.length, pattern, pattern.length, pos, max_edit_distance)
+        match = Match.new(*result, self.seq[result[0] ... result[0] + result[1]]);
+
+        if block_given?
+          yield match
+        else
+          matches << match
+        end
+
+        pos = match.beg + 1
+      end
+
+      return matches unless block_given?
+    end
+
+    private
+
+    inline do |builder|
+      add_ambiguity_macro(builder)
+
+      # Macro for matching nucleotides including ambiguity codes.
+      builder.prefix %{
+        #define MAX_PAT 1024
+      }
+
+      builder.prefix %{
+        typedef struct 
+        {
+          unsigned int mis;
+          unsigned int ins;
+          unsigned int del;
+          unsigned int ed;
+        } score;
+      }
+
+      builder.prefix %{
+        void vector_init(score *vec, unsigned int vec_len)
+        {
+          unsigned int i = 0;
+
+          for (i = 1; i < vec_len; i++)
+          {
+            vec[i].ins = i;
+            vec[i].ed  = i;
+          }
+        }
+      }
+
+      builder.prefix %{
+        void vector_print(score *vec, unsigned int vec_len)
+        {
+          unsigned int i = 0;
+
+          for (i = 0; i < vec_len; i++)
+          {
+            printf("i: %d   mis: %d   ins: %d   del: %d   ed: %d\\n", i, vec[i].mis, vec[i].ins, vec[i].del, vec[i].ed);
+          }
+
+          printf("---\\n");
+        }
+      }
+
+      builder.prefix %{
+        int match_found(score *vec, unsigned int pat_len, unsigned int max_ed)
+        {
+          return (vec[pat_len].ed <= max_ed);
+        }
+      }
+
+      builder.prefix %{
+        void vector_update(score *vec, char *seq, char *pat, unsigned int pat_len, unsigned int pos)
+        {
+          score diag = vec[0];
+          score up   = {0, 0, 0, 0};   // insertion
+          score left = vec[1];            // deletion
+          score new  = {0, 0, 0, 0};
+
+          unsigned int i = 0;
+
+          for (i = 0; i < pat_len; i++)
+          {
+            if (MATCH(seq[pos], pat[i]))                        // match
+            {
+              new = diag;
+            }
+            else
+            {
+              if (left.ed <= diag.ed && left.ed <= up.ed)       // deletion
+              {
+                new = left;
+                new.del++;
+              }
+              else if (diag.ed <= up.ed && diag.ed <= left.ed)   // mismatch
+              {
+                new = diag;
+                new.mis++;
+              }
+              else if (up.ed <= diag.ed && up.ed <= left.ed)      // insertion
+              {
+                new = up;
+                new.ins++;
+              }
+              else
+              {
+                printf("This should not happen\\n");
+                exit(1);
+              }
+
+              new.ed++;
+            }
+
+            diag = vec[i + 1];
+            up   = new;
+            left = vec[i + 2];
+
+            vec[i + 1] = new;
+          }
+        }
+      }
+
+      builder.c %{
+        VALUE match_C(
+          VALUE _seq,       // Sequence
+          VALUE _seq_len,   // Sequence length
+          VALUE _pat,       // Pattern
+          VALUE _pat_len,   // Pattern length
+          VALUE _pos,       // Offset position
+          VALUE _max_ed     // Maximum edit distance
+        )
+        {
+          char         *seq     = (char *) StringValuePtr(_seq);
+          char         *pat     = (char *) StringValuePtr(_pat);
+          unsigned int  seq_len = FIX2UINT(_seq_len);
+          unsigned int  pat_len = FIX2UINT(_pat_len);
+          unsigned int  pos     = FIX2UINT(_pos);
+          unsigned int  max_ed  = FIX2UINT(_max_ed);
+          
+          score         vec[MAX_PAT] = {0};
+          unsigned int  vec_len      = pat_len + 1;
+          unsigned int  match_beg    = 0;
+          unsigned int  match_len    = 0;
+
+          VALUE         match_ary;
+
+          vector_init(vec, vec_len);
+
+          while (pos < seq_len)
+          {
+            vector_update(vec, seq, pat, pat_len, pos);
+
+            if (match_found(vec, pat_len, max_ed))
+            {
+              match_len = pat_len - vec[pat_len].ins + vec[pat_len].del;
+              match_beg = pos - match_len + 1;
+
+              match_ary = rb_ary_new();
+              rb_ary_push(match_ary, INT2FIX(match_beg));
+              rb_ary_push(match_ary, INT2FIX(match_len));
+              rb_ary_push(match_ary, INT2FIX(vec[pat_len].mis));
+              rb_ary_push(match_ary, INT2FIX(vec[pat_len].ins));
+              rb_ary_push(match_ary, INT2FIX(vec[pat_len].del));
+
+              return match_ary;
+            }
+
+            pos++;
+          }
+
+          return Qfalse;  // no match
+        }
+      }
+    end
+
+    class Match
+      attr_accessor :beg, :length, :mis, :ins, :del, :match
+
+      def initialize(beg, length, mis, ins, del, match)
+        @beg    = beg
+        @length = length
+        @mis    = mis
+        @ins    = ins
+        @del    = del
+        @match  = match
+      end
+    end
+  end
+end
+
+
+__END__

data/lib/BioDSL/seq/homopolymer.rb

@@ -0,0 +1,59 @@
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                                #
+# Copyright (C) 2007-2015 Martin Asser Hansen (mail@maasha.dk).                  #
+#                                                                                #
+# This program is free software; you can redistribute it and/or                  #
+# modify it under the terms of the GNU General Public License                    #
+# as published by the Free Software Foundation; either version 2                 #
+# of the License, or (at your option) any later version.                         #
+#                                                                                #
+# This program is distributed in the hope that it will be useful,                #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of                 #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                  #
+# GNU General Public License for more details.                                   #
+#                                                                                #
+# You should have received a copy of the GNU General Public License              #
+# along with this program; if not, write to the Free Software                    #
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. #
+#                                                                                #
+# http://www.gnu.org/copyleft/gpl.html                                           #
+#                                                                                #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                                #
+# This software is part of BioDSL (www.BioDSL.org).                        #
+#                                                                                #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+
+module BioDSL
+  # Error class for all exceptions to do with Homopolymer.
+  class HomopolymerError < StandardError; end
+
+  module Homopolymer
+    def each_homopolymer(min = 1)
+      raise HomopolymerError, "Bad min value: #{min}" if min <= 0
+      list = []
+
+      self.seq.upcase.scan(/A{#{min},}|T{#{min},}|G{#{min},}|C{#{min},}|N{#{min},}/) do |match|
+        hp = Homopolymer.new(match, match.length, $`.length)
+
+        if block_given?
+          yield hp
+        else
+          list << hp
+        end
+      end
+
+      block_given? ? self : list
+    end
+
+    class Homopolymer
+      attr_reader :pattern, :length, :pos
+
+      def initialize(pattern, length, pos)
+        @pattern = pattern
+        @length  = length
+        @pos     = pos
+      end
+    end
+  end
+end