bioinform 0.1.12 → 0.1.13

data/lib/bioinform/data_models/motif.rb

@@ -1,56 +1,56 @@
-require 'ostruct'
-require_relative '../support/third_part/active_support/core_ext/object/try'
-require_relative '../support/parameters'
-module Bioinform
-  class Motif
-    include Parameters
-    make_parameters :pcm, :pwm, :ppm, :name, :original_data_model
-
-    # 0)Motif.new()
-    # 1)Motif.new(pcm: ..., pwm: ..., name: ...,threshold: ...)
-    # 2)Motif.new(my_pcm)
-    # 3)Motif.new(pm: my_pcm, threshold: ...)
-    # 2) and 3) cases will automatically choose data model
-    #### What if pm already is a Motif
-    def initialize(parameters = {})
-      case parameters
-      when PM
-        pm = parameters
-        motif_type = pm.class.name.downcase.sub(/^.+::/,'').to_sym
-        self.original_data_model = motif_type
-        set_parameters(motif_type => pm)
-      when Hash
-        if parameters.has_key?(:pm) && parameters[:pm].is_a?(PM)
-          pm = parameters.delete(:pm)
-          motif_type = pm.class.name.downcase.sub(/^.+::/,'').to_sym
-          self.original_data_model = motif_type
-          set_parameters(motif_type => pm)
-        end
-        set_parameters(parameters)
-      else
-        raise ArgumentError, "Motif::new doesn't accept argument #{parameters} of class #{parameters.class}"
-      end
-    end
-
-    def pm; ((original_data_model || :pm) == :pm) ? parameters.pm : send(original_data_model); end
-    #def pcm; parameters.pcm; end
-    def pwm; parameters.pwm || pcm.try(:to_pwm); end
-    def ppm; parameters.ppm || pcm.try(:to_ppm); end
-    #def pcm=(pcm); parameters.pcm = pcm; end
-    #def pwm=(pwm); parameters.pwm = pwm; end
-    #def ppm=(ppm); parameters.ppm = ppm; end
-    def name; parameters.name || pm.name; end
-
-    def method_missing(meth, *args)
-      parameters.__send__(meth, *args)
-    end
-
-    def ==(other)
-      parameters == other.parameters
-    end
-    
-    def to_s
-      parameters.to_s
-    end
-  end
+require 'ostruct'
+require_relative '../support/third_part/active_support/core_ext/object/try'
+require_relative '../support/parameters'
+module Bioinform
+  class Motif
+    include Parameters
+    make_parameters :pcm, :pwm, :ppm, :name, :original_data_model
+
+    # 0)Motif.new()
+    # 1)Motif.new(pcm: ..., pwm: ..., name: ...,threshold: ...)
+    # 2)Motif.new(my_pcm)
+    # 3)Motif.new(pm: my_pcm, threshold: ...)
+    # 2) and 3) cases will automatically choose data model
+    #### What if pm already is a Motif
+    def initialize(parameters = {})
+      case parameters
+      when PM
+        pm = parameters
+        motif_type = pm.class.name.downcase.sub(/^.+::/,'').to_sym
+        self.original_data_model = motif_type
+        set_parameters(motif_type => pm)
+      when Hash
+        if parameters.has_key?(:pm) && parameters[:pm].is_a?(PM)
+          pm = parameters.delete(:pm)
+          motif_type = pm.class.name.downcase.sub(/^.+::/,'').to_sym
+          self.original_data_model = motif_type
+          set_parameters(motif_type => pm)
+        end
+        set_parameters(parameters)
+      else
+        raise ArgumentError, "Motif::new doesn't accept argument #{parameters} of class #{parameters.class}"
+      end
+    end
+
+    def pm; ((original_data_model || :pm) == :pm) ? parameters.pm : send(original_data_model); end
+    #def pcm; parameters.pcm; end
+    def pwm; parameters.pwm || pcm.try(:to_pwm); end
+    def ppm; parameters.ppm || pcm.try(:to_ppm); end
+    #def pcm=(pcm); parameters.pcm = pcm; end
+    #def pwm=(pwm); parameters.pwm = pwm; end
+    #def ppm=(ppm); parameters.ppm = ppm; end
+    def name; parameters.name || pm.name; end
+
+    def method_missing(meth, *args)
+      parameters.__send__(meth, *args)
+    end
+
+    def ==(other)
+      parameters == other.parameters
+    end
+    
+    def to_s
+      parameters.to_s
+    end
+  end
 end

data/lib/bioinform/data_models/pcm.rb

@@ -1,24 +1,24 @@
-require_relative '../support'
-require_relative '../data_models'
-require_relative '../conversion_algorithms/pcm2ppm_converter'
-require_relative '../conversion_algorithms/pcm2pwm_converter'
-
-module Bioinform
-  class PCM < PM
-    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)
-    end
-  end
+require_relative '../support'
+require_relative '../data_models'
+require_relative '../conversion_algorithms/pcm2ppm_converter'
+require_relative '../conversion_algorithms/pcm2pwm_converter'
+
+module Bioinform
+  class PCM < PM
+    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)
+    end
+  end
 end

data/lib/bioinform/data_models/pm.rb

@@ -1,170 +1,170 @@
-require 'ostruct'
-require_relative '../support'
-require_relative '../parsers'
-require_relative '../formatters'
-
-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, StringFantomParser, JasparParser, TrivialCollectionParser, YAMLCollectionParser].find do |parser|
-        self.new(input, parser) rescue nil
-      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
-      self.name = result.name
-#      self.tags = result.tags || []
-      self.background = result.background || [1, 1, 1, 1]
-      raise 'matrix not valid'  unless valid?
-    end
-
-    def ==(other)
-      @matrix == other.matrix && background == other.background && name == other.name
-    rescue
-      false
-    end
-
-    def self.valid_matrix?(matrix)
-      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 valid?
-      self.class.valid_matrix?(@matrix)
-    end
-
-    def each_position
-      if block_given?
-        matrix.each{|pos| yield pos}
-      else
-        self.to_enum(:each_position)
-      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 pretty_string(options = {})
-      default_options = {with_name: true, letters_as_rows: false}
-
-      return to_s(options)  if options[:letters_as_rows]
-
-      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(' ')
-      end
-
-      matrix_str = matrix_rows.join("\n")
-
-      if options[:with_name] && name
-        name + "\n" + header + matrix_str
-      else
-        header + matrix_str
-      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]} ]
-      end
-      hsh.with_indifferent_access
-    end
-
-    def self.zero_column
-      [0, 0, 0, 0]
-    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 discrete!(rate)
-      @matrix.map!{|position| position.map{|element| (element * rate).ceil}}
-      self
-    end
-
-    def vocabulary_volume
-      background.inject(&:+) ** length
-    end
-
-    def probability
-      sum = background.inject(0.0, &:+)
-      background.map{|element| element.to_f / sum}
-    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 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
+require 'ostruct'
+require_relative '../support'
+require_relative '../parsers'
+require_relative '../formatters'
+
+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, StringFantomParser, JasparParser, TrivialCollectionParser, YAMLCollectionParser].find do |parser|
+        self.new(input, parser) rescue nil
+      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
+      self.name = result.name
+#      self.tags = result.tags || []
+      self.background = result.background || [1, 1, 1, 1]
+      raise 'matrix not valid'  unless valid?
+    end
+
+    def ==(other)
+      @matrix == other.matrix && background == other.background && name == other.name
+    rescue
+      false
+    end
+
+    def self.valid_matrix?(matrix)
+      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 valid?
+      self.class.valid_matrix?(@matrix)
+    end
+
+    def each_position
+      if block_given?
+        matrix.each{|pos| yield pos}
+      else
+        self.to_enum(:each_position)
+      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 pretty_string(options = {})
+      default_options = {with_name: true, letters_as_rows: false}
+
+      return to_s(options)  if options[:letters_as_rows]
+
+      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(' ')
+      end
+
+      matrix_str = matrix_rows.join("\n")
+
+      if options[:with_name] && name
+        name + "\n" + header + matrix_str
+      else
+        header + matrix_str
+      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]} ]
+      end
+      hsh.with_indifferent_access
+    end
+
+    def self.zero_column
+      [0, 0, 0, 0]
+    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 discrete!(rate)
+      @matrix.map!{|position| position.map{|element| (element * rate).ceil}}
+      self
+    end
+
+    def vocabulary_volume
+      background.inject(&:+) ** length
+    end
+
+    def probability
+      sum = background.inject(0.0, &:+)
+      background.map{|element| element.to_f / sum}
+    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 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,10 +1,10 @@
-require_relative '../support'
-require_relative '../data_models'
-
-module Bioinform
-  class PPM < PM
-    def to_ppm
-      self
-    end
-  end
+require_relative '../support'
+require_relative '../data_models'
+
+module Bioinform
+  class PPM < PM
+    def to_ppm
+      self
+    end
+  end
 end

data/lib/bioinform/data_models/pwm.rb

@@ -1,56 +1,56 @@
-require_relative '../support'
-require_relative '../data_models'
-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
-    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
-
-    def worst_suffix(i)
-      @matrix[i...length].map(&:min).inject(0.0, &:+)
-    end
-  end
+require_relative '../support'
+require_relative '../data_models'
+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
+    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
+
+    def worst_suffix(i)
+      @matrix[i...length].map(&:min).inject(0.0, &:+)
+    end
+  end
 end

data/lib/bioinform/data_models.rb

@@ -1,11 +1,11 @@
-require_relative 'parsers'
-
-require_relative 'data_models/pm'
-require_relative 'data_models/pcm'
-require_relative 'data_models/ppm'
-require_relative 'data_models/pwm'
-
-require_relative 'data_models/collection'
-
-#require_relative 'bioinform/data_models/iupac_word'
+require_relative 'parsers'
+
+require_relative 'data_models/pm'
+require_relative 'data_models/pcm'
+require_relative 'data_models/ppm'
+require_relative 'data_models/pwm'
+
+require_relative 'data_models/collection'
+
+#require_relative 'bioinform/data_models/iupac_word'
 #require_relative 'bioinform/data_models/iupac_wordset'