bioinform 0.1.17 → 0.2.0

data/lib/bioinform/data_models/named_model.rb

@@ -0,0 +1,38 @@
+module Bioinform
+  module MotifModel
+    class NamedModel
+      attr_reader :model, :name
+      def initialize(model, name)
+        @model, @name = model, name
+      end
+
+      def motif_klasses
+        Bioinform::MotifModel.constants.map{|konst| Bioinform::MotifModel.const_get(konst) }.select{|konst| konst.is_a? Class }
+      end
+
+      def motif?(object)
+        motif_klasses.any?{|klass| object.is_a?(klass) }
+      end
+
+      private :motif_klasses, :motif?
+
+      def method_missing(meth, *args, &block)
+        result = model.public_send(meth, *args, &block)
+        if motif?(result) && ! result.is_a?(self.class)
+          self.class.new(result, name)
+        else
+          result
+        end
+      end
+
+      # should not be delegated to self (because in that case name won't be displayed)
+      def to_s
+        MotifFormatter.new.format(self)
+      end
+
+      def ==(other)
+        model == other.model && name == other.name
+      end
+    end
+  end
+end

data/lib/bioinform/data_models/pcm.rb

@@ -1,36 +1,26 @@
-require_relative '../support'
-require_relative '../data_models'
-require_relative '../conversion_algorithms/pcm2ppm_converter'
-require_relative '../conversion_algorithms/pcm2pwm_converter'
+require_relative 'pm'
 
 module Bioinform
-  class PCM < PM
-    make_parameters :pseudocount
-
-    def count
-      matrix.first.inject(&:+)
-    end
-
-    def to_pcm
-      self
-    end
-
-    def to_pwm(pseudocount = Math.log(count))
-      ConversionAlgorithms::PCM2PWMConverter.convert(self, pseudocount: pseudocount)
-    end
-
-    def to_ppm
-      ConversionAlgorithms::PCM2PPMConverter.convert(self)
+  module MotifModel
+    def self.acts_as_pcm?(pcm)
+      pcm.is_a?(MotifModel::PCM) || pcm.is_a?(MotifModel::NamedModel) && acts_as_pcm?(pcm.model)
     end
 
-    def self.valid_matrix?(matrix, options = {})
-      super && matrix.all?{|pos| pos.all?{|el| el >=0 } }
-    end
+    class PCM < PM
+      def validation_errors
+        errors = super
+        errors << "elements of PCM should be non-negative"  unless matrix.all?{|pos| pos.all?{|el| el >= 0 } }
+        errors
+      end
 
-    def validation_errors(options = {})
-      validation_errors = []
-      validation_errors << "PCM matrix should contain only non-negative elements"  unless matrix.all?{|pos| pos.all?{|el| el >=0 } }
-      super + validation_errors
+      def count
+        counts = each_position.map{|pos| pos.inject(0.0, &:+)}
+        count = counts.first
+        diffs = counts.map{|pos_count| (pos_count - count).abs }
+        counts_are_same = (diffs.max < count * 1e-3)
+        raise Error, 'Different columns have different count'  unless counts_are_same
+        count
+      end
     end
   end
 end

data/lib/bioinform/data_models/pm.rb

@@ -1,198 +1,101 @@
-require 'ostruct'
-require_relative '../support'
-require_relative '../parsers'
-require_relative '../formatters'
+require_relative '../formatters/motif_formatter'
+require_relative '../errors'
+require_relative '../alphabet'
+require_relative 'named_model'
 
 module Bioinform
-  IndexByLetter = { 'A' => 0, 'C' => 1, 'G' => 2, 'T' => 3, A: 0, C: 1, G: 2, T: 3,
-                    'a' => 0, 'c' => 1, 'g' => 2, 't' => 3, a: 0, c: 1, g: 2, t: 3}
-  LetterByIndex = {0 => :A, 1 => :C, 2 => :G, 3 => :T}
-
-  class PM
-    attr_accessor :matrix, :parameters
-
-    include Parameters
-    make_parameters  :name, :background # , :tags
-
-#    def mark(tag)
-#      tags << tag
-#    end
-
-#    def tagged?(tag)
-#      tags.any?{|t| (t.eql? tag) || (t.respond_to?(:name) && t.name && (t.name == tag)) }
-#    end
-
-    def self.choose_parser(input)
-      [TrivialParser, YAMLParser, Parser, StringParser, Bioinform::MatrixParser.new(has_name: false).wrapper, Bioinform::MatrixParser.new(has_name: true).wrapper, StringFantomParser, JasparParser, TrivialCollectionParser, YAMLCollectionParser].find do |parser|
-        self.new(input, parser) rescue nil
+  module MotifModel
+    class PM
+      attr_reader :matrix, :alphabet
+      def initialize(matrix, options = {})
+        @matrix = matrix
+        @alphabet = options.fetch(:alphabet, NucleotideAlphabet)
+        raise ValidationError.new('invalid matrix', validation_errors: validation_errors)  unless valid?
       end
-    end
-
-    def self.split_on_motifs(input)
-      parser = choose_parser(input)
-      raise ParsingError, "No parser can parse given input"  unless parser
-      parser.split_on_motifs(input, self)
-    end
-
-    def initialize(input, parser = nil)
-      @parameters = OpenStruct.new
-      parser ||= self.class.choose_parser(input)
-      raise 'No one parser can process input'  unless parser
-      result = parser.new(input).parse
-      @matrix = result.matrix
-      raise 'Non valid matrix' unless self.class.valid_matrix?(@matrix)
-      self.name = result.name
-#      self.tags = result.tags || []
-      self.background = result.background || [1, 1, 1, 1]
-    end
-
-    def self.new_with_validation(input, parser = nil)
-      obj = self.new(input, parser)
-      raise 'matrix not valid'  unless obj.valid?
-      obj
-    end
-    def ==(other)
-      @matrix == other.matrix && background == other.background && name == other.name
-    rescue
-      false
-    end
-
-    def self.valid_matrix?(matrix, options = {})
-      matrix.is_a?(Array) &&
-      ! matrix.empty? &&
-      matrix.all?{|pos| pos.is_a?(Array)} &&
-      matrix.all?{|pos| pos.size == 4} &&
-      matrix.all?{|pos| pos.all?{|el| el.is_a?(Numeric)}}
-    rescue
-      false
-    end
 
-    def validation_errors(options = {})
-      errors = []
-      if !matrix.is_a?(Array)
-        errors << 'Matrix is not an array'
-      elsif matrix.empty?
-        errors << 'Matrix is not an array'
-      elsif ! matrix.all?{|pos| pos.is_a?(Array)}
-        errors << 'Some of matrix positions aren\'t represented as arrays'
-      elsif ! matrix.all?{|pos| pos.size == 4}
-        errors << 'Some of matrix positions have number of columns other than 4'
-      elsif ! matrix.all?{|pos| pos.all?{|el| el.is_a?(Numeric)}}
-        errors << 'Some of matrix elements aren\'t represented by numbers'
+      def self.from_string(input, options = {})
+        parser = options.fetch(:parser, MatrixParser.new)
+        alphabet = options.fetch(:alphabet, NucleotideAlphabet)
+        info = parser.parse!(input)
+        self.new(info[:matrix], alphabet: alphabet).named( info[:name] )
       end
-      errors
-    end
-
-    def valid?(options = {})
-      self.class.valid_matrix?(@matrix, options)
-    end
 
-    def each_position
-      if block_given?
-        matrix.each{|pos| yield pos}
-      else
-        self.to_enum(:each_position)
+      def self.from_file(filename, options = {})
+        parser = options.fetch(:parser, MatrixParser.new)
+        alphabet = options.fetch(:alphabet, NucleotideAlphabet)
+        info = parser.parse!(File.read(filename))
+        name = (info[:name] && !info[:name].strip.empty?) ? info[:name] : File.basename(filename, File.extname(filename))
+        self.new(info[:matrix], alphabet: alphabet).named( name )
       end
-    end
-
-    def length
-      @matrix.length
-    end
-    alias_method :size, :length
 
-    def to_s(options = {}, formatter = RawFormatter)
-      formatter.new(self, options).to_s
-    end
+      def validation_errors
+        errors = []
+        errors << "matrix should be an Array"  unless matrix.is_a? Array
+        errors << "matrix shouldn't be empty"  unless matrix.size > 0
+        errors << "each matrix position should be an Array"  unless matrix.all?{|pos| pos.is_a?(Array) }
+        errors << "each matrix position should be of size compatible with alphabet (=#{alphabet.size})"  unless matrix.all?{|pos| pos.size == alphabet.size }
+        errors << "each matrix element should be Numeric"  unless matrix.all?{|pos| pos.all?{|el| el.is_a?(Numeric) } }
+        errors
+      end
+      private :validation_errors
 
-    def pretty_string(options = {})
-      default_options = {with_name: true, letters_as_rows: false}
+      def valid?
+       validation_errors.empty?
+      rescue
+        false
+      end
 
-      return to_s(options)  if options[:letters_as_rows]
+      private :valid?
 
-      options = default_options.merge(options)
-      header = %w{A C G T}.map{|el| el.rjust(4).ljust(7)}.join + "\n"
-      matrix_rows = each_position.map do |position|
-        position.map{|el| el.round(3).to_s.rjust(6)}.join(' ')
+      def length
+        matrix.size
       end
 
-      matrix_str = matrix_rows.join("\n")
-
-      if options[:with_name] && name
-        name + "\n" + header + matrix_str
-      else
-        header + matrix_str
+      def to_s
+        MotifFormatter.new.format(self)
       end
-    end
 
-    def consensus
-      each_position.map{|pos|
-        pos.each_with_index.max_by{|el, letter_index| el}
-      }.map{|el, letter_index| letter_index}.map{|letter_index| %w{A C G T}[letter_index] }.join
-    end
+      def ==(other)
+        self.class == other.class && matrix == other.matrix && alphabet == other.alphabet
+      end
 
+      def each_position
+        if block_given?
+          matrix.each{|pos| yield pos}
+        else
+          self.to_enum(:each_position)
+        end
+      end
 
-    def to_hash
-      hsh = %w{A C G T}.each_with_index.collect_hash do |letter, letter_index|
-        [ letter, @matrix.map{|pos| pos[letter_index]} ]
+      def reversed
+        self.class.new(matrix.reverse, alphabet: alphabet)
       end
-      hsh.with_indifferent_access
-    end
 
-    def self.zero_column
-      [0, 0, 0, 0]
-    end
+      def complemented
+        self.class.new(complement_matrix, alphabet: alphabet)
+      end
 
-    def reverse_complement!
-      @matrix.reverse!.map!(&:reverse!)
-      self
-    end
-    def left_augment!(n)
-      n.times{ @matrix.unshift(self.class.zero_column) }
-      self
-    end
-    def right_augment!(n)
-      n.times{ @matrix.push(self.class.zero_column) }
-      self
-    end
+      def reverse_complemented
+        self.class.new(complement_matrix.reverse, alphabet: alphabet)
+      end
 
-    def discrete!(rate)
-      @matrix.map!{|position| position.map{|element| (element * rate).ceil}}
-      self
-    end
+      alias_method :revcomp, :reverse_complemented
 
-    def vocabulary_volume
-      background.inject(&:+) ** length
-    end
+      def complement_matrix
+        matrix.map{|pos|
+          alphabet.each_letter_index.map{|letter_index| pos[alphabet.complement_index(letter_index)]}
+        }
+      end
+      private :complement_matrix
 
-    def probability
-      sum = background.inject(0.0, &:+)
-      background.map{|element| element.to_f / sum}
-    end
+      # def consensus
+      #   ConsensusFormatter.by_maximal_elements.format_string(self)
+      # end
 
-    def reverse_complement
-      dup.reverse_complement!
-    end
-    def left_augment(n)
-      dup.left_augment!(n)
-    end
-    def right_augment(n)
-      dup.right_augment!(n)
-    end
-    def discrete(rate)
-      dup.discrete!(rate)
-    end
-    def dup
-      deep_dup
-    end
+      def named(name)
+        NamedModel.new(self, name)
+      end
 
-    def as_pcm
-      PCM.new(get_parameters.merge(matrix: matrix))
-    end
-    def as_ppm
-      PPM.new(get_parameters.merge(matrix: matrix))
-    end
-    def as_pwm
-      PWM.new(get_parameters.merge(matrix: matrix))
     end
   end
 end

data/lib/bioinform/data_models/ppm.rb

@@ -1,31 +1,18 @@
-require_relative '../support'
-require_relative '../data_models'
+require_relative 'pm'
 
 module Bioinform
-  class PPM < PM
-    make_parameters :effective_count, :pseudocount
-    def to_ppm
-      self
+  module MotifModel
+    def self.acts_as_ppm?(ppm)
+      ppm.is_a?(MotifModel::PPM) || ppm.is_a?(MotifModel::NamedModel) && acts_as_ppm?(ppm.model)
     end
 
-    def to_pcm
-      PCM.new(matrix.map{|pos| pos.map{|el| el * effective_count} }).tap{|pcm| pcm.name = name}
-    end
-
-    def to_pwm
-      pseudocount ? to_pcm.to_pwm(pseudocount) : to_pcm.to_pwm
-    end
-
-    def self.valid_matrix?(matrix, options = {})
-      precision = options[:precision] || 0.01
-      super && matrix.all?{|pos| ((pos.inject(0, &:+) - 1.0).abs <= precision)  && pos.all?{|el| el >=0 } }
-    end
-    def validation_errors(options = {})
-      precision = options[:precision] || 0.01
-      validation_errors = []
-      validation_errors << "PPM matrix should contain only non-negative elements"  unless matrix.all?{|pos| pos.all?{|el| el >=0 } }
-      validation_errors << "Sum of PPM matrix elements for each position should equal to 1"  unless matrix.all?{|pos| ((pos.inject(0, &:+) - 1.0).abs <= precision) }
-      super + validation_errors
+    class PPM < PM
+      def validation_errors
+        errors = super
+        errors << "elements of PPM should be non-negative"  unless matrix.all?{|pos| pos.all?{|el| el >= 0 } }
+        errors << "each PPM position should be equal to 1.0 being summed"  unless matrix.all?{|pos| (pos.inject(0.0, &:+) - 1.0).abs < 1e-3 }
+        errors
+      end
     end
   end
 end

data/lib/bioinform/data_models/pwm.rb

@@ -1,67 +1,41 @@
-require_relative '../support'
-require_relative '../data_models'
+require_relative 'pm'
 
 module Bioinform
-  class PWM < PM
-    def score_mean
-      each_position.inject(0){ |mean, position| mean + position.each_index.inject(0){|sum, letter| sum + position[letter] * probability[letter]} }
-    end
-    def score_variance
-      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
-
-    def threshold_gauss_estimation(pvalue)
-      sigma = Math.sqrt(score_variance)
-      n_ = Math.inverf(1 - 2 * pvalue) * Math.sqrt(2)
-      score_mean + n_ * sigma
-    end
-
-    def score(word)
-      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}
-      (0...length).map do |pos|
-        letter = word[pos]
-        if IndexByLetter[letter]
-          matrix[pos][IndexByLetter[letter]]
-        elsif letter == 'N'
-          matrix[pos].zip(probability).map{|el, p| el * p}.inject(0, &:+)
-        else
-          raise ArgumentError, "word in PWM#score(#{word}) should have only ACGT or N letters"
-        end
-      end.inject(0, &:+).to_f
-    end
-
-    def to_pwm
-      self
+  module MotifModel
+    def self.acts_as_pwm?(pwm)
+      pwm.is_a?(MotifModel::PWM) || pwm.is_a?(MotifModel::NamedModel) && acts_as_pwm?(pwm.model)
     end
 
-    def best_score
-      best_suffix(0)
-    end
-    def worst_score
-      worst_suffix(0)
-    end
-
-    # best score of suffix s[i..l]
-    def best_suffix(i)
-      @matrix[i...length].map(&:max).inject(0.0, &:+)
-    end
+    class PWM < PM
+      def score(word)
+        raise Error, 'Word length should be the same as PWM length'  unless word.length == length
+        length.times.map do |pos|
+          matrix[pos][alphabet.index_by_letter(word[pos])]
+        end.inject(0.0, &:+)
+      end
 
-    def worst_suffix(i)
-      @matrix[i...length].map(&:min).inject(0.0, &:+)
-    end
+      def discreted(rate, options = {})
+        rounding_method = options.fetch(:rounding_method, :ceil)
+        discreted_matrix = matrix.map{|position| position.map{|element| (element * rate).send(rounding_method) } }
+        self.class.new(discreted_matrix, alphabet: alphabet)
+      end
 
+      def zero_column
+        [0.0] * alphabet.size
+      end
+      private :zero_column
 
-    def matrix_rounded(n)
-      matrix.map{|pos| pos.map{|x| x.round(n) } }
-    end
-    private :matrix_rounded
+      def left_augmented(n)
+        raise Error, 'Augmenting with negative number of columns is impossible'  if n < 0
+        augmented_matrix = Array.new(n, zero_column) + matrix
+        self.class.new(augmented_matrix, alphabet: alphabet)
+      end
 
-    def round(n)
-      PWM.new(matrix_rounded(n)).tap{|pm| pm.name = name}
+      def right_augmented(n)
+        raise Error, 'Augmenting with negative number of columns is impossible'  if n < 0
+        augmented_matrix = matrix + Array.new(n, zero_column)
+        self.class.new(augmented_matrix, alphabet: alphabet)
+      end
     end
   end
 end