BioDSL 1.0.0

data/lib/BioDSL/seq/kmer.rb

@@ -0,0 +1,293 @@
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                                #
+# 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 Kmer.
+  class KmerError < StandardError; end
+
+  # Module containing methods for manipulating sequence kmers.
+  module Kmer
+    # Debug method to convert an array of binary encoded kmers to
+    # nucleotide oligos.
+    def self.to_oligos(kmers, kmer_size)
+      oligos = []
+
+      kmers.each do |kmer|
+        oligo = ""
+        bin   = "%0#{kmer_size * 2}b" % kmer
+
+        bin.scan(/.{2}/) { |m|
+          case m
+          when '00' then oligo << 'a'
+          when '01' then oligo << 't'
+          when '10' then oligo << 'c'
+          when '11' then oligo << 'g'
+          else
+            raise "unknown m #{m}"
+          end
+        }
+
+        oligos << oligo
+      end
+
+      oligos
+    end
+
+    # Method that returns a sorted array of unique kmers, which are integer
+    # representations of DNA/RNA sequence oligos where A is encoded in two bits
+    # as 00, T as 01, U as 01, C as 10 and G as 11. Oligos with other nucleotides
+    # are ignored. The following options apply:
+    #   * kmer_size: kmer size in the range 1-12.
+    #   * step_size: step size in the range 1-12 (defualt=1).
+    #   * score_min: drop kmers with quality score below this.
+    def to_kmers(options)
+      options[:step_size] ||= 1
+      options[:score_min] ||= Seq::SCORE_MAX
+      raise KmerError, "No kmer_size" unless options[:kmer_size]
+      raise KmerError, "Bad kmer_size: #{options[:kmer_size]}" unless (1 .. 12).include? options[:kmer_size]
+      raise KmerError, "Bad step_size: #{options[:step_size]}" unless (1 .. 12).include? options[:step_size]
+      if self.qual and not (Seq::SCORE_MIN .. Seq::SCORE_MAX).include? options[:score_min]
+        raise KmerError, "score minimum: #{options[:score_min]} out of range #{Seq::SCORE_MIN} .. #{Seq::SCORE_MAX}"
+      end
+
+      size = Seq::DNA.size ** options[:kmer_size]
+
+      if defined? @kmer_ary and @kmer_ary.count == size
+        @kmer_ary.zero!
+      else
+        @kmer_ary = BioDSL::CAry.new(size, 1)
+      end
+
+      if self.qual
+        to_kmers_qual_C(self.seq, self.qual, @kmer_ary.ary, self.length, @kmer_ary.count, options[:kmer_size], options[:step_size], options[:score_min], Seq::SCORE_BASE)
+      else
+        to_kmers_C(self.seq, @kmer_ary.ary, self.length, @kmer_ary.count, options[:kmer_size], options[:step_size])
+      end
+    end
+
+    private
+
+    inline do |builder|
+      builder.prefix %{
+        int encode_nuc(char nuc, unsigned int *bin)
+        {
+          *bin <<= 2;
+
+          switch(nuc)
+          {
+            case 'a':
+              *bin |= 0;
+              break;
+            case 'A':
+              *bin |= 0;
+              break;
+            case 't':
+              *bin |= 1;
+              break;
+            case 'T':
+              *bin |= 1;
+              break;
+            case 'u':
+              *bin |= 1;
+              break;
+            case 'U':
+              *bin |= 1;
+              break;
+            case 'c':
+              *bin |= 2;
+              break;
+            case 'C':
+              *bin |= 2;
+              break;
+            case 'g':
+              *bin |= 3;
+              break;
+            case 'G':
+              *bin |= 3;
+              break;
+            default:
+              return 0;
+          }
+
+          return 1;
+        }
+      }
+
+      builder.c %{
+        VALUE to_kmers_C(
+          VALUE _seq,         // DNA or RNA sequence string.
+          VALUE _ary,         // byte array for sort and uniq.
+          VALUE _seq_len,     // sequence length.
+          VALUE _ary_len,     // byte array length.
+          VALUE _kmer_size,   // Size of kmer or oligo.
+          VALUE _step_size    // Step size for overlapping kmers.
+        )
+        {
+          char         *seq       = StringValuePtr(_seq);
+          char         *ary       = StringValuePtr(_ary);
+          unsigned int  seq_len   = FIX2UINT(_seq_len);
+          unsigned int  ary_len   = FIX2UINT(_ary_len);
+          unsigned int  kmer_size = FIX2UINT(_kmer_size);
+          unsigned int  step_size = FIX2UINT(_step_size);
+          
+          VALUE         array = rb_ary_new();
+          unsigned int  bin   = 0;
+          unsigned int  enc   = 0;
+          unsigned int  i     = 0;
+          unsigned int  mask  = (1 << (2 * kmer_size)) - 1;
+
+          for (i = 0; i < seq_len; i++)
+          {
+            if (encode_nuc(seq[i], &bin))
+            {
+              enc++;
+
+              if (((i % step_size) == 0) && (enc >= kmer_size)) {
+                ary[(bin & mask)] = 1;
+              }
+            }
+            else
+            {
+              enc = 0;
+            }
+          }
+
+          for (i = 0; i < ary_len; i++)
+          {
+            if (ary[i]) {
+              rb_ary_push(array, INT2FIX(i));
+            }
+          }
+
+          return array;
+        }
+      }
+
+      builder.c %{
+        VALUE to_kmers_qual_C(
+          VALUE _seq,         // DNA or RNA sequence string.
+          VALUE _qual,        // Quality score string.
+          VALUE _ary,         // Byte array for sort and uniq.
+          VALUE _seq_len,     // Sequence length.
+          VALUE _ary_len,     // Byte array length.
+          VALUE _kmer_size,   // Size of kmer or oligo.
+          VALUE _step_size,   // Step size for overlapping kmers.
+          VALUE _score_min,   // Miminum quality score to accept in a kmer.
+          VALUE _score_base   // Quality score base.
+        )
+        {
+          char         *seq        = StringValuePtr(_seq);
+          char         *qual       = StringValuePtr(_qual);
+          char         *ary        = StringValuePtr(_ary);
+          unsigned int  seq_len    = FIX2UINT(_seq_len);
+          unsigned int  ary_len    = FIX2UINT(_ary_len);
+          unsigned int  kmer_size  = FIX2UINT(_kmer_size);
+          unsigned int  step_size  = FIX2UINT(_step_size);
+          unsigned int  score_min  = FIX2UINT(_score_min);
+          unsigned int  score_base = FIX2UINT(_score_base);
+          
+          VALUE         array = rb_ary_new();
+          unsigned int  bin   = 0;
+          unsigned int  enc   = 0;
+          unsigned int  i     = 0;
+          unsigned int  mask  = (1 << (2 * kmer_size)) - 1;
+
+          for (i = 0; i < seq_len; i++)
+          {
+            if (encode_nuc(seq[i], &bin))
+            {
+              enc++;
+
+              if ((unsigned int) qual[i] - score_base < score_min)
+              {
+                enc = 0;
+              }
+              else if ((enc >= kmer_size) && ((i % step_size) == 0))
+              {
+                ary[(bin & mask)] = 1;
+              }
+            }
+            else
+            {
+              enc = 0;
+            }
+          }
+
+          for (i = 0; i < ary_len; i++)
+          {
+            if (ary[i]) {
+              rb_ary_push(array, INT2FIX(i));
+            }
+          }
+
+          return array;
+        }
+      }
+    end
+
+    def naive(options)
+      oligos = []
+
+      (0 .. self.length - options[:kmer_size]).each do |i|
+        oligo = self[i ... i + options[:kmer_size]]
+
+        next unless oligo.seq.upcase =~ /^[ATUCG]+$/
+        next if oligo.qual and options[:scores_min] and oligo.scores_min < options[:scores_min]
+
+        oligos << oligo.seq.upcase
+      end
+
+      oligos
+    end
+
+    def naive_bin(options)
+      oligos = []
+
+      (0 .. self.length - options[:kmer_size]).each do |i|
+        oligo = self[i ... i + options[:kmer_size]]
+
+        next unless oligo.seq.upcase =~ /^[ATCG]+$/
+        next if oligo.qual and options[:scores_min] and oligo.scores_min < options[:scores_min]
+
+        bin = 0
+
+        oligo.seq.upcase.each_char do |c|
+          bin <<= 2
+          case c
+          when 'T' then bin |= 1
+          when 'U' then bin |= 1
+          when 'C' then bin |= 2
+          when 'G' then bin |= 3
+          end
+        end
+
+        oligos << bin
+      end
+
+      oligos
+    end
+  end
+end

data/lib/BioDSL/seq/levenshtein.rb

@@ -0,0 +1,113 @@
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                                #
+# 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 the BioDSL framework (www.BioDSL.org).          #
+#                                                                                #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+
+module BioDSL
+  # Class to calculate the Levenshtein distance between two
+  # given strings.
+  # http://en.wikipedia.org/wiki/Levenshtein_distance
+  class Levenshtein
+    extend BioDSL::Ambiguity
+
+    BYTES_IN_INT = 4
+
+    def self.distance(s, t)
+      return 0        if s == t;
+      return t.length if s.length == 0;
+      return s.length if t.length == 0;
+
+      v0 = "\0" * (t.length + 1) * BYTES_IN_INT
+      v1 = "\0" * (t.length + 1) * BYTES_IN_INT
+
+      l = self.new
+      l.levenshtein_distance_C(s, t, s.length, t.length, v0, v1)
+    end
+
+    # >>>>>>>>>>>>>>> RubyInline C code <<<<<<<<<<<<<<<
+
+    inline do |builder|
+      add_ambiguity_macro(builder)
+
+      builder.prefix %{
+        unsigned int min(unsigned int a, unsigned int b, unsigned int c)
+        {
+            unsigned int m = a;
+
+            if (m > b) m = b;
+            if (m > c) m = c;
+
+            return m;
+        }
+      }
+
+      builder.c %{
+        VALUE levenshtein_distance_C(
+          VALUE _s,       // string
+          VALUE _t,       // string
+          VALUE _s_len,   // string length
+          VALUE _t_len,   // string length
+          VALUE _v0,      // score vector
+          VALUE _v1       // score vector
+        )
+        {
+          char         *s     = (char *) StringValuePtr(_s);
+          char         *t     = (char *) StringValuePtr(_t);
+          unsigned int  s_len = FIX2UINT(_s_len);
+          unsigned int  t_len = FIX2UINT(_t_len);
+          unsigned int  *v0   = (unsigned int *) StringValuePtr(_v0);
+          unsigned int  *v1   = (unsigned int *) StringValuePtr(_v1);
+
+          unsigned int i    = 0;
+          unsigned int j    = 0;
+          unsigned int cost = 0;
+         
+          for (i = 0; i < t_len + 1; i++)
+            v0[i] = i;
+         
+          for (i = 0; i < s_len; i++)
+          {
+            v1[0] = i + 1;
+         
+            for (j = 0; j < t_len; j++)
+            {
+              cost = (MATCH(s[i], t[j])) ? 0 : 1;
+              v1[j + 1] = min(v1[j] + 1, v0[j + 1] + 1, v0[j] + cost);
+            }
+         
+            for (j = 0; j < t_len + 1; j++)
+              v0[j] = v1[j];
+          }
+         
+          return UINT2NUM(v1[t_len]);
+        }
+      }
+    end
+  end
+end
+
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+
+__END__

data/lib/BioDSL/seq/translate.rb

@@ -0,0 +1,109 @@
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                                #
+# 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
+  module Translate
+    # Translation table 11
+    # (http://www.ncbi.nlm.nih.gov/Taxonomy/taxonomyhome.html/index.cgi?chapter=cgencodes#SG11)
+    #   AAs  = FFLLSSSSYY**CC*WLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG
+    # Starts = ---M---------------M------------MMMM---------------M------------
+    # Base1  = TTTTTTTTTTTTTTTTCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGGGGGGGGGG
+    # Base2  = TTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGG
+    # Base3  = TCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAG
+    TRANS_TAB11_START = {
+      "TTG" => "M", "CTG" => "M", "ATT" => "M", "ATC" => "M",
+      "ATA" => "M", "ATG" => "M", "GTG" => "M"
+    }
+
+    TRANS_TAB11 = {
+      "TTT" => "F", "TCT" => "S", "TAT" => "Y", "TGT" => "C",
+      "TTC" => "F", "TCC" => "S", "TAC" => "Y", "TGC" => "C",
+      "TTA" => "L", "TCA" => "S", "TAA" => "*", "TGA" => "*",
+      "TTG" => "L", "TCG" => "S", "TAG" => "*", "TGG" => "W",
+      "CTT" => "L", "CCT" => "P", "CAT" => "H", "CGT" => "R",
+      "CTC" => "L", "CCC" => "P", "CAC" => "H", "CGC" => "R",
+      "CTA" => "L", "CCA" => "P", "CAA" => "Q", "CGA" => "R",
+      "CTG" => "L", "CCG" => "P", "CAG" => "Q", "CGG" => "R",
+      "ATT" => "I", "ACT" => "T", "AAT" => "N", "AGT" => "S",
+      "ATC" => "I", "ACC" => "T", "AAC" => "N", "AGC" => "S",
+      "ATA" => "I", "ACA" => "T", "AAA" => "K", "AGA" => "R",
+      "ATG" => "M", "ACG" => "T", "AAG" => "K", "AGG" => "R",
+      "GTT" => "V", "GCT" => "A", "GAT" => "D", "GGT" => "G",
+      "GTC" => "V", "GCC" => "A", "GAC" => "D", "GGC" => "G",
+      "GTA" => "V", "GCA" => "A", "GAA" => "E", "GGA" => "G",
+      "GTG" => "V", "GCG" => "A", "GAG" => "E", "GGG" => "G"
+    }
+
+    # Method to translate a DNA sequence to protein.
+    def translate!(trans_tab = 11)
+      entry = translate(trans_tab)
+
+      self.seq_name = entry.seq_name ? entry.seq_name.dup : nil
+      self.seq      = entry.seq.dup
+      self.type     = entry.type
+      self.qual     = entry.qual
+
+      self
+    end
+
+    alias :to_protein! :translate!
+
+    def translate(trans_tab = 11)
+      raise SeqError, "Sequence type must be 'dna' - not #{self.type}" unless self.type == :dna
+      raise SeqError, "Sequence length must be a multiplum of 3 - was: #{self.length}" unless (self.length % 3) == 0
+
+      case trans_tab
+      when 11
+        codon_start_hash = TRANS_TAB11_START
+        codon_hash       = TRANS_TAB11
+      else
+        raise SeqError, "Unknown translation table: #{trans_tab}"
+      end
+
+      codon = self.seq[0 ... 3].upcase
+
+      aa = codon_start_hash[codon]
+
+      raise SeqError, "Unknown start codon: #{codon}" if aa.nil?
+
+      protein = aa.dup
+
+      (3 ... self.length).step(3) do |i|
+        codon = self.seq[i ... i + 3].upcase
+
+        aa = codon_hash[codon]
+
+        raise SeqError, "Unknown codon: #{codon}" if aa.nil?
+
+        protein << aa.dup
+      end
+
+      Seq.new(seq_name: self.seq_name, seq: protein[0 .. -2], type: :protein)
+    end
+
+    alias :to_protein :translate
+  end
+end