bioinform 0.1.17 → 0.2.0

data/lib/bioinform/cli/pcm2pwm.rb

@@ -1,47 +1,53 @@
 require_relative '../../bioinform'
-require 'docopt'
+require 'optparse'
 require 'shellwords'
 
 module Bioinform
-  module CLI  
+  module CLI
     module PCM2PWM
       extend Bioinform::CLI::Helpers
       def self.main(argv)
-        doc = <<-DOCOPT
-          PCM to PWM converter.
-          It transforms files with PCMs into files with PWMs. Folder for resulting files to save files can be specified. Resulting PWM files have the same name as original file but have another extension (.pwm by default).
-          When filelist is empty, it's obtained from STDIN. One can use it: `ls -b pcm_folder/*.pcm | pcm2pwm` (ls -b option escape spaces in filenames)
-
-          Usage:
-            pcm2pwm [options] [<pcm-files>...]
-
-          Options:
-            -h --help           Show this screen.
-            -e --extension EXT  Extension of output files [default: pwm]
-            -f --folder FOLDER  Where to save output files [default: .]
-        DOCOPT
-
-        doc.gsub!(/^#{doc[/\A +/]}/,'')
-        options = Docopt::docopt(doc, argv: argv)
+        options = {folder: '.', extension: 'pwm'}
+        opt_parser = OptionParser.new do |opts|
+          opts.banner = "PCM to PWM converter.\n" +
+                        "It transforms files with PCMs into files with PWMs.\n" +
+                        "Folder for resulting files to save files can be specified.\n" +
+                        "Resulting PWM files have the same name as original file but have another extension (.pwm by default).\n" +
+                        "When filelist is empty, it's obtained from STDIN.\n" +
+                        "One can use it: `ls -b pcm_folder/*.pcm | pcm2pwm` (ls -b option escape spaces in filenames)\n" +
+                        "\n" +
+                        "Usage:\n" +
+                        "  pcm2pwm [options] [<pcm-files>...]"
+          opts.version = ::Bioinform::VERSION
+          opts.on('-e', '--extension EXT', 'Extension of output files [default: pwm]') do |v|
+            options[:extension] = v
+          end
+          opts.on('-f', '--folder FOLDER', 'Where to save output files') do |v|
+            options[:folder] = v
+          end
+        end
 
-        pcm_files = options['<pcm-files>']
-        folder = options['--folder']
-        extension = options['--extension']
+        opt_parser.parse!(argv)
+        pcm_files = argv
+        folder = options[:folder]
+        extension = options[:extension]
 
         Dir.mkdir(folder)  unless Dir.exist?(folder)
         filelist = (pcm_files.empty?)  ?  $stdin.read.shellsplit  :  pcm_files
 
+        converter = ConversionAlgorithms::PCM2PWMConverter.new()
+
         filelist.each do |filename|
-          pwm = Bioinform::PCM.new( File.read(filename) ).to_pwm
+          input = File.read(filename)
+          motif_data = MatrixParser.new.parse(input)
+          pcm = MotifModel::PCM.new(motif_data[:matrix]).named(motif_data[:name])
+          pwm = converter.convert(pcm)
           File.open(change_folder_and_extension(filename, extension, folder), 'w') do |f|
             f.puts pwm
           end
         end
-
-      rescue Docopt::Exit => e
-        puts e.message
       end
 
     end
   end
-end
+end

data/lib/bioinform/cli/split_motifs.rb

@@ -1,47 +1,48 @@
 require_relative '../../bioinform'
-require 'docopt'
+require 'optparse'
 
 module Bioinform
   module CLI
     module SplitMotifs
       extend Bioinform::CLI::Helpers
       def self.main(argv)
-        doc = <<-DOCOPT
-          Motif splitter.
-          It get a file with a set of motifs and splits it into motifs according to their names.
-
-          Usage:
-            split_motifs [options] <collection-file>
-
-          Options:
-            -h --help                Show this screen.
-            -e --extension EXT       Extension of output files
-            -f --folder FOLDER       Where to save output files [default: .]
-        DOCOPT
+        options = {folder: '.'}
+        opt_parser = OptionParser.new do |opts|
+          opts.version = ::Bioinform::VERSION
+          opts.banner = "Motif splitter.\n" +
+                        "It gets a file with a set of motifs and splits it into motifs according to their names.\n" +
+                        "\n" +
+                        "Usage:\n" +
+                        "  split_motifs [options] <collection-file>"
+          opts.on('-e', '--extension EXT', 'Extension of output files') do |v|
+            options[:extension] = v
+          end
+          opts.on('-f', '--folder FOLDER', 'Where to save output files') do |v|
+            options[:folder] = v
+          end
+        end
 
-        doc.gsub!(/^#{doc[/\A +/]}/,'')
-        options = Docopt::docopt(doc, argv: argv)
+        opt_parser.parse!(argv)
+        folder = options[:folder]
+        extension = options[:extension]
+        collection_filename = argv.first
 
-        folder = options['--folder']
-        extension = options['--extension']
-        collection_filename = options['<collection-file>']
 
         Dir.mkdir(folder)  unless Dir.exist?(folder)
-        raise "File #{collection_filename} not exist"  unless File.exist? collection_filename
+        raise "Collection file not specified"  unless collection_filename
+        raise "File `#{collection_filename}` not exist"  unless File.exist?(collection_filename)
 
-        input = File.read(collection_filename)
-        Parser.choose(input).split.each do |motif|
-          if motif.is_a? PM
-            File.open(set_folder(folder, set_extension(motif.name, extension || motif.class.name.gsub(/^.*::/,'').downcase)), 'w'){|f| f.puts motif}
-          else
-            motif = PM.new(motif)
-            File.open(set_folder(folder, set_extension(motif.name, extension || 'mat')), 'w'){|f| f.puts motif}
-          end
+        motif_list_string = File.read(collection_filename)
+        coll = MotifSplitter.new.split(motif_list_string).map do |motif_string|
+          motif_info = MatrixParser.new.parse(motif_string)
+          MotifModel::PM.new(motif_info[:matrix]).named(motif_info[:name])
+        end
+
+        coll.each do |motif|
+          File.open(set_folder(folder, set_extension(motif.name, extension || 'mat')), 'w'){|f| f.puts motif }
         end
-      rescue Docopt::Exit => e
-        puts e.message
       end
 
     end
   end
-end
+end

data/lib/bioinform/conversion_algorithms.rb

@@ -0,0 +1,6 @@
+require_relative 'conversion_algorithms/pcm2ppm_converter'
+require_relative 'conversion_algorithms/pcm2pwm_converter'
+require_relative 'conversion_algorithms/ppm2pcm_converter'
+require_relative 'conversion_algorithms/pwm2pcm_converter'
+require_relative 'conversion_algorithms/pwm2iupac_pwm_converter'
+require_relative 'conversion_algorithms/pcm2pwm_mara_converter'

data/lib/bioinform/conversion_algorithms/pcm2ppm_converter.rb

@@ -1,19 +1,21 @@
+require_relative '../data_models'
+
 module Bioinform
   module ConversionAlgorithms
-    module PCM2PPMConverter
-    
-      # parameters hash is ignored
-      def self.convert(pcm, parameters = {})
+    class PCM2PPMConverter
+      def convert(pcm)
+        raise Error, "#{self.class}#convert accepts only models acting as PCM"  unless MotifModel.acts_as_pcm?(pcm)
         matrix = pcm.each_position.map do |pos|
-          pos.map do |el|
-            el.to_f / pcm.count
-          end
+          count = pos.inject(0.0, &:+)
+          pos.map {|el| el / count }
+        end
+        ppm = MotifModel::PPM.new(matrix)
+        if pcm.respond_to? :name
+          ppm.named(pcm.name)
+        else
+          ppm
         end
-        PPM.new(pcm.get_parameters.merge(matrix: matrix))
       end
     end
   end
 end
-
-
-      

data/lib/bioinform/conversion_algorithms/pcm2pwm_converter.rb

@@ -1,20 +1,48 @@
+require_relative '../errors'
+require_relative '../data_models'
+require_relative '../background'
+
 module Bioinform
   module ConversionAlgorithms
-    module PCM2PWMConverter
-      def self.convert(pcm, parameters = {})
-        default_parameters = {pseudocount: Math.log(pcm.count),
-                              probability: (pcm.probability || [0.25, 0.25, 0.25, 0.25])
-                              }
-        parameters = default_parameters.merge(parameters)
-        probability = parameters[:probability]
-        pseudocount = parameters[:pseudocount]
+    # s_{\alpha,j} = ln(\frac{x_{\alpha,j} + \cappa p_{\alpha}}{(N+\cappa)p_{\alpha}})
+    class PCM2PWMConverter
+      attr_reader :background, :pseudocount
+      def initialize(options = {})
+        @background = options.fetch(:background, Bioinform::Background::Uniform)
+        @pseudocount = options.fetch(:pseudocount, :log)
+      end
+
+      def calculate_pseudocount(pcm)
+        case @pseudocount
+        when Numeric
+          @pseudocount
+        when :log
+          Math.log(pcm.count)
+        when :sqrt
+          Math.sqrt(pcm.count)
+        when Proc
+          @pseudocount.call(pcm)
+        else
+          raise Error, 'Unknown pseudocount type use numeric or :log or :sqrt or Proc with taking pcm parameter'
+        end
+      end
+
+      def convert(pcm)
+        raise Error, "#{self.class}#convert accepts only models acting as PCM"  unless MotifModel.acts_as_pcm?(pcm)
+        actual_pseudocount = calculate_pseudocount(pcm)
         matrix = pcm.each_position.map do |pos|
+          count = pos.inject(0.0, &:+)
           pos.each_index.map do |index|
-            Math.log((pos[index] + probability[index] * pseudocount) / (probability[index]*(pcm.count + pseudocount)) )
+            Math.log((pos[index] + @background.frequencies[index] * actual_pseudocount).to_f / (@background.frequencies[index]*(count + actual_pseudocount)) )
           end
         end
-        PWM.new(pcm.get_parameters.merge(matrix: matrix))
+        pwm = MotifModel::PWM.new(matrix)
+        if pcm.respond_to? :name
+          pwm.named(pcm.name)
+        else
+          pwm
+        end
       end
     end
   end
-end
+end

data/lib/bioinform/conversion_algorithms/pcm2pwm_mara_converter.rb

@@ -0,0 +1,26 @@
+require_relative '../errors'
+require_relative '../data_models'
+require_relative '../background'
+
+module Bioinform
+  module ConversionAlgorithms
+    # s_{\alpha,j} = ln(\frac{x_{\alpha,j} + \cappa p_{\alpha}}{(N+\cappa)p_{\alpha}})
+    class MaraPCM2PWMConverter
+      def convert(pcm)
+        raise Error, "#{self.class}#convert accepts only models acting as PCM"  unless MotifModel.acts_as_pcm?(pcm)
+        matrix = pcm.each_position.map do |pos|
+          count = pos.inject(0.0, &:+)
+          pos.each_index.map do |index|
+            Math.log((pos[index] + 0.5).to_f / (0.25 * (count + 2)) )
+          end
+        end
+        pwm = MotifModel::PWM.new(matrix)
+        if pcm.respond_to? :name
+          pwm.named(pcm.name)
+        else
+          pwm
+        end
+      end
+    end
+  end
+end

data/lib/bioinform/conversion_algorithms/ppm2pcm_converter.rb

@@ -0,0 +1,30 @@
+require_relative '../errors'
+require_relative '../data_models'
+
+module Bioinform
+  module ConversionAlgorithms
+    class PPM2PCMConverter
+      attr_reader :count
+
+      def initialize(options = {})
+        @count = options.fetch(:count, 100)
+      end
+
+      def convert(ppm)
+        raise Error, "#{self.class}#convert accepts only models acting as PPM"  unless MotifModel.acts_as_ppm?(ppm)
+        matrix = ppm.each_position.map do |pos|
+          pos.map do |el|
+            el * @count
+          end
+        end
+
+        pcm = MotifModel::PCM.new(matrix)
+        if ppm.respond_to? :name
+          pcm.named(ppm.name)
+        else
+          pcm
+        end
+      end
+    end
+  end
+end

data/lib/bioinform/conversion_algorithms/pwm2iupac_pwm_converter.rb

@@ -0,0 +1,23 @@
+require_relative '../alphabet'
+
+module Bioinform
+  module ConversionAlgorithms
+    class PWM2IupacPWMConverter
+      attr_reader :iupac_alphabet
+      def initialize(options = {})
+        @iupac_alphabet = options.fetch(:alphabet, NucleotideAlphabetWithN)
+      end
+      def convert(pwm)
+        raise Error, "Can convert only PWMs"  unless MotifModel.acts_as_pwm?(pwm)
+        raise Error, 'this conversion is possible only for ACGT-nucleotide motifs'  unless pwm.alphabet == NucleotideAlphabet
+        iupac_matrix = pwm.each_position.map do |pos|
+          @iupac_alphabet.each_letter.map do |letter|
+            nucleotide_indices = IUPAC::NucleotideIndicesByIUPACLetter[letter]
+            nucleotide_indices.inject(0.0){|sum, nucleotide_index| sum + pos[nucleotide_index] } / nucleotide_indices.size
+          end
+        end
+        MotifModel::PWM.new(iupac_matrix, alphabet: @iupac_alphabet)
+      end
+    end
+  end
+end

data/lib/bioinform/conversion_algorithms/pwm2pcm_converter.rb

@@ -0,0 +1,85 @@
+require_relative '../data_models'
+
+module Bioinform
+  module ConversionAlgorithms
+
+    # This algorithm is a purely heuristic based on our algorithm of PWM calculation.
+    # pcm --> pwm:
+    #   s_{\alpha,j} = ln(\frac{x_{\alpha,j} + \cappa p_{\alpha}}{(N+\cappa)p_{\alpha}}) - \beta_{j}
+    #   \beta_j is an arbitrary constant
+    # Hence
+    # pwm --> pcm:
+    #   x_{\alpha,j} = (N + \cappa) p_{\alpha} \exp{ s_{\alpha,j} - \beta_j } - \cappa p_{\alpha}
+    #   \beta_j = log(\sum_{\alpha}p_{\alpha}s_{\alpha,j})  because \sum_{\alpha} x_{\alpha,j} = N
+    class PWM2PCMConverter
+      attr_reader :pseudocount, :count, :background
+
+      def initialize(options = {})
+        @pseudocount = options.fetch(:pseudocount, :default)
+        @count = options.fetch(:count, 100.0)
+        @background = options.fetch(:background, Bioinform::Background::Uniform)
+      end
+
+      def calculate_pseudocount(pwm)
+        case @pseudocount
+        when Numeric
+          @pseudocount
+        when :default
+          # *0.95 is to guarantee that rounding errors won't exceed real max pseudocount and generate PCM with negative elements
+          max_pseudocount = max_pseudocount_fraction(pwm) * @count
+          (Math.log(@count) <= max_pseudocount*0.95) ? Math.log(@count) : max_pseudocount * 0.95
+        when Proc
+          @pseudocount.call(pwm)
+        else
+          raise Error, 'Unknown pseudocount type use numeric or :default or Proc with taking pcm parameter'
+        end
+      end
+
+      # \sum p_{\alpha} s_{\alpha,j}
+      def weighted_position_exponent(pos)
+        pos.each_with_index.map {|elem, letter_index| @background.frequencies[letter_index] * Math.exp(elem) }.inject(0.0, &:+)
+      end
+
+      # possible  (pseudocount / count) range is from 0 to max_pseudocount_fraction
+      # it's derived from
+      # (-\exp{s_{\alpha,j}} + \sum_{\alpha} p_{\alpha,j}\exp{s_{\alpha,j}}) * pseudocount  <  count * \exp{s_{\alpha,j}}
+      # which is derived from the fact that each element of PCM should be not less than 0
+      def max_pseudocount_fraction(pwm)
+        # min = 0.0
+        max = Float::INFINITY
+        pwm.each_position do |pos|
+          pos.each_with_index do |elem, letter_index|
+            coeff = weighted_position_exponent(pos) -  Math.exp(elem)
+            if coeff > 0
+              max = [Math.exp(elem) / coeff, max].min
+            # elsif coeff < 0
+              # min = [Math.exp(elem) / coeff, min].max # Math.exp(elem) / coeff is always < 0 hence minimal pseudocount is zero
+            end
+          end
+        end
+        max
+      end
+
+      private :max_pseudocount_fraction, :weighted_position_exponent
+
+      def convert(pwm)
+        raise Error, "Can convert only PWMs"  unless MotifModel.acts_as_pwm?(pwm)
+        actual_pseudocount = calculate_pseudocount(pwm)
+        matrix = pwm.each_position.map do |pos|
+          beta = Math.log( weighted_position_exponent(pos) )
+          pwm_pos = pos.each_index.map do |index|
+            (@count + actual_pseudocount) * @background.frequencies[index] * Math.exp( pos[index] ) * Math.exp( -beta ) - actual_pseudocount * @background.frequencies[index]
+          end
+          pwm_pos
+        end
+
+        pcm = MotifModel::PCM.new(matrix)
+        if pwm.respond_to? :name
+          pcm.named(pwm.name)
+        else
+          pcm
+        end
+      end
+    end
+  end
+end

data/lib/bioinform/data_models.rb

@@ -1,11 +1,5 @@
-require_relative 'parsers'
-
+require_relative 'data_models/named_model'
 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'