bioinform 0.1.3 → 0.1.4

data/lib/bioinform/data_models/pcm.rb

@@ -2,6 +2,18 @@ require 'bioinform/support'
 require 'bioinform/data_models/pm'
 module Bioinform
   class PCM < PM
+    def count
+      matrix.first.inject(&:+)
+    end
     
+    def to_pwm(pseudocount = Math.log(count))
+      mat = each_position.map do |pos|
+        pos.each_index.map do |ind|
+          Math.log((pos[ind] + probability[ind] * pseudocount) / (probability[ind]*(count + pseudocount)) )
+        end
+      end
+      PWM.new(mat)
+    end
+
   end
 end

data/lib/bioinform/data_models/pm.rb

@@ -1,87 +1,75 @@
 require 'bioinform/support'
+require 'bioinform/parsers'
 
 module Bioinform
   IndexByLetter = {'A' => 0, 'C' => 1, 'G' => 2, 'T' => 3}
   LetterByIndex = {0 => 'A', 1 => 'C', 2 => 'G', 3 => 'T'}
 
   class PM
-    attr_reader :matrix, :background
-    attr_accessor :name
+    attr_reader :matrix
+    attr_accessor :background, :name
     
-    def initialize(input = nil, parser = nil)
+    def choose_parser(input)
+      input.is_a?(String) ? StringParser : Parser
+      [Parser, StringParser, StringFantomParser].find do |parser|
+        self.class.new(input, parser) rescue nil
+      end
+    end
+    
+    def initialize(input, parser = nil)
+      parser ||= choose_parser(input)
+      result = parser.new(input).parse   
+      @matrix = result[:matrix]
+      @name = result[:name]
       @background = [1, 1, 1, 1]
-      @input = input
-      @parser = parser
-      return unless @input
-      parser_init
-      matrix_init
+      raise 'matrix not valid'  unless valid?
     end
     
     def ==(other)
       @matrix == other.matrix && @background == other.background
     end
     
-    def parser_init
-      if @parser
-        raise ArgumentError, 'Input cannot be parsed by specified parser' unless @parser.new(@input).can_parse?
-      else
-        @parser = Parser.subclasses.find{|parser_class| parser_class.new(@input).can_parse? }
-        raise ArgumentError, 'No one parser can parse specified input' unless @parser
-      end
-    end
-    
-    def matrix_init
-      parse_result = @parser.new(@input).parse
-      raise ArgumentError, 'Used parser result has no `matrix` key'  unless parse_result.has_key? :matrix
-     
-      configure_from_hash(parse_result)
-    end
-    
     def valid?
-      @matrix.is_a?(Array) && 
+      @matrix.is_a?(Array) &&
       @matrix.all?(&:is_a?.(Array)) &&
-      @matrix.all?(&:all?.(&:is_a?.(Numeric))) && 
-      @matrix.all?{|pos| pos.size == 4}
+      @matrix.all?{|pos| pos.size == 4} &&
+      @matrix.all?(&:all?.(&:is_a?.(Numeric)))
     rescue 
       false
     end
     
-    def configure_from_hash(parse_result)
-      parse_result.each{|key, value|  send("#{key}=", value)  if respond_to? "#{key}="  }
-    end
-    
-    def matrix=(new_matrix)
-      old_matrix, @matrix = matrix, new_matrix
-      raise ArgumentError, 'Matrix has invalid format:' unless valid?
-    rescue
-      @matrix = old_matrix
-      raise
+    def each_position
+      if block_given?
+        matrix.each{|pos| yield pos}
+      else
+        Enumerator.new(self, :each_position)
+      end
     end
-    
-    def length;  
-      @matrix.length;
+        
+    def length
+      @matrix.length
     end
     alias_method :size, :length
     
     def to_s(with_name = true)
-      matrix = @matrix.map(&:join.("\t")).join("\n")
+      matrix_str = each_position.map(&:join.("\t")).join("\n")
       if with_name && @name 
-        "#{@name}\n#{matrix}"
+        "#{@name}\n#{matrix_str}"
       else 
-        matrix
+        matrix_str
       end
     end
     
     def pretty_string(with_name = true)
       header = %w{A C G T}.map{|el| el.rjust(4).ljust(7)}.join + "\n"
-      matrix_rows = @matrix.map do |position|  
+      matrix_rows = each_position.map do |position|
         position.map{|el| el.round(3).to_s.rjust(6)}.join(' ')
       end
-      matrix = matrix_rows.join("\n")
+      matrix_str = matrix_rows.join("\n")
       if with_name && @name
-        @name + "\n" + header + matrix
+        @name + "\n" + header + matrix_str
       else
-        header + matrix
+        header + matrix_str
       end
     end
     
@@ -133,17 +121,13 @@ module Bioinform
       self
     end
 
-    def background_sum
-      @background.inject(0.0, &:+)
-    end
-
     def vocabulary_volume
-      background_sum ** length
+      background.inject(&:+) ** length
     end
     
     def probability
-      sum = background_sum
-      @background.map{|element| element.to_f / sum}
+      sum = background.inject(0.0, &:+)
+      background.map{|element| element.to_f / sum}
     end
 
 

data/lib/bioinform/data_models/pwm.rb

@@ -3,12 +3,12 @@ require 'bioinform/data_models/pm'
 module Bioinform
   class PWM < PM
     def score_mean
-      matrix.inject(0.0){ |mean, position| mean + position.each_index.inject(0.0){|sum, letter| sum + position[letter] * probability[letter]} }
+      each_position.inject(0){ |mean, position| mean + position.each_index.inject(0){|sum, letter| sum + position[letter] * probability[letter]} }
     end
     def score_variance
-      matrix.inject(0.0) do |variance, position|
-        variance  + position.each_index.inject(0.0) { |sum,letter| sum + position[letter]**2 * probability[letter] } -
-                    position.each_index.inject(0.0) { |sum,letter| sum + position[letter]    * probability[letter] }**2
+      each_position.inject(0) do |variance, position|
+        variance  + position.each_index.inject(0) { |sum,letter| sum + position[letter]**2 * probability[letter] } -
+                    position.each_index.inject(0) { |sum,letter| sum + position[letter]    * probability[letter] }**2
       end
     end
     
@@ -20,9 +20,9 @@ module Bioinform
     
     def score(word)
       word = word.upcase
-      raise ArgumentError  unless word.length == length
-      raise ArgumentError  unless word.each_char.all?{|letter| %w{A C G T}.include? letter}
-      word.each_char.map.with_index{|letter, pos| matrix[pos][IndexByLetter[letter]] }.inject(0.0, &:+)
+      raise ArgumentError, 'word in PWM#score(word) should have the same length as matrix'  unless word.length == length
+      raise ArgumentError, 'word in PWM#score(word) should have only ACGT-letters'  unless word.each_char.all?{|letter| %w{A C G T}.include? letter}
+      word.each_char.map.with_index{|letter, pos| matrix[pos][IndexByLetter[letter]] }.inject(&:+)
     end
   end
 end

data/lib/bioinform/data_models.rb

@@ -1,3 +1,5 @@
+require 'bioinform/parsers'
+
 require 'bioinform/data_models/pm'
 require 'bioinform/data_models/pcm'
 require 'bioinform/data_models/pwm'

data/lib/bioinform/parsers/parser.rb

@@ -0,0 +1,40 @@
+require 'bioinform/support'
+
+module Bioinform
+  class Parser
+    attr_reader :input, :matrix
+    
+    def initialize(input)
+      @input = input
+    end
+    
+    def parse
+      inp = input
+      transpose =  inp.is_a?(Hash)
+      inp = ClassMethods.try_convert_to_array(inp)
+      inp.map!{|x| ClassMethods.try_convert_to_array(x)}
+      transpose = true  if (not inp.all?{|x| x.size == 4}) && inp.size == 4 && inp.same_by?(&:size)
+      @matrix = transpose ? inp.transpose : inp
+      result
+    rescue
+      {}
+    end
+      
+    def result(options={})
+      raise 'Parsing Error' unless matrix.is_a?(Array) && matrix.all?(&:is_a?.(Array)) && matrix.all?{|pos| pos.size == 4} && matrix.all?(&:all?.(&:is_a?.(Numeric)))
+      options.merge(matrix: @matrix)
+    end
+    
+    class ClassMethods
+      def self.array_from_acgt_hash(hsh)
+        hsh = hsh.collect_hash{|key,value| [key.to_s.upcase, value] }
+        raise 'some of hash keys A,C,G,T are missing or hash has excess keys' unless hsh.keys.sort == %w[A C G T]
+        %w[A C G T].collect{|letter| hsh[letter] }
+      end
+      def self.try_convert_to_array(inp)
+        return inp  if inp.is_a? Array
+        array_from_acgt_hash(inp)
+      end
+    end
+  end
+end

data/lib/bioinform/{data_models/parsers → parsers}/string_fantom_parser.rb

@@ -1,6 +1,5 @@
 require 'bioinform/support'
-require 'bioinform/data_models/parser'
-require 'bioinform/data_models/parsers/string_parser'
+require 'bioinform/parsers/string_parser'
 
 module Bioinform
   class StringFantomParser < StringParser

data/lib/bioinform/{data_models/parsers → parsers}/string_parser.rb

@@ -1,8 +1,7 @@
 require 'bioinform/support'
-require 'bioinform/data_models/parser'
-require 'bioinform/data_models/parsers/array_parser'
+require 'bioinform/parsers/parser'
 
-module Bioinform
+module Bioinform  
   class StringParser < Parser
     def number_pat
       '[+-]?\d+(\.\d+)?([eE][+-]?\d{1,3})?'
@@ -28,18 +27,19 @@ module Bioinform
       matrix.split("\n").map{|line| line.split.map(&:to_f)}
     end
 
-    def parse_core
+    def parse
       case input
-      when String      
+      when String
         match = input.multiline_squish.match(pattern)
         raise ArgumentError  unless match
         matrix = matrix_preprocess( match[:matrix] )
         raise ArgumentError  unless matrix
-        result = ArrayParser.new(matrix).parse
-        match[:name]  ?  result.merge(name: match[:name])  :  result
+        Parser.new(matrix).parse.merge(name: match[:name])
       else
         raise ArgumentError
       end
+    rescue
+      {}
     end
   end
 end

data/lib/bioinform/parsers.rb

@@ -0,0 +1,3 @@
+require 'bioinform/parsers/parser'
+require 'bioinform/parsers/string_parser'
+require 'bioinform/parsers/string_fantom_parser'

data/lib/bioinform/support/partial_sums.rb

@@ -1,3 +1,5 @@
+require 'bioinform/support/collect_hash'
+
 class Array
   def partial_sums(initial = 0.0)
     sums = initial

data/lib/bioinform/version.rb

@@ -1,3 +1,3 @@
 module Bioinform
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

data/lib/bioinform.rb

@@ -1,7 +1,6 @@
 require 'bioinform/version'
 require 'bioinform/support'
 require 'bioinform/data_models'
-require 'bioinform/data_models/parsers'
 
 module Bioinform
   # Your code goes here...

data/spec/data_models/pcm_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'bioinform/data_models/pcm'
+
+module Bioinform
+  describe PCM do
+    describe '#count' do
+      it 'should be equal to sum of elements at position' do
+        PCM.new([[1, 2, 3, 1],[4, 1, 1, 2]]).count.should == 7
+        PCM.new([[1, 2.3, 3.2, 1],[4.4, 1.1, 1, 2]]).count.should == 7.5
+      end
+    end
+    
+    describe '#to_pwm' do
+      it 'should return PWM' do
+        PCM.new([[1, 2, 3, 1],[4, 1, 1, 2]]).to_pwm.should be_kind_of(PWM) 
+      end
+      it 'should make transformation: el --> log( (el + p_i*pseudocount) / (p_i*(count + pseudocount)) )' do
+        PCM.new([[1, 2, 3, 1],[4, 1, 1, 2]]).to_pwm(1).matrix.map{|line|line.map{|el| el.round(3)}}.should == [[-0.47, 0.118,0.486,-0.47],[0.754,-0.47,-0.47,0.118]]
+        PCM.new([[1, 2, 3, 1],[4, 1, 1, 2]]).to_pwm(10).matrix.map{|line|line.map{|el| el.round(3)}}.should == [[-0.194, 0.057,0.258,-0.194],[0.425,-0.194,-0.194,0.057]]
+      end
+      it 'should use default pseudocount equal to log(count)' do
+        PCM.new([[1, 2, 3, 1],[4, 1, 1, 2]]).to_pwm.should == PCM.new([[1, 2, 3, 1],[4, 1, 1, 2]]).to_pwm(Math.log(7))
+      end
+    end
+    
+  end
+end