macroape 3.2.2

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+TODO.txt

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in macroape.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2011-2012 Ilya Vorontsov, Ivan Kulakovskiy, Vsevolod Makeev
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,61 @@
+# Macroape
+
+Macroape is abbreviation for MAtrix CompaRisOn by Approximate P-value Estimation. It's a bioinformatic tool for evaluating similarity measure between a pair of Position Weight Matrices. Used approach and application described in manual at https://docs.google.com/document/pub?id=1_jsxhMNzMzy4d2d_byAd3n6Szg5gEcqG_Sf7w9tEqWw
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'macroape'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install macroape
+
+## Usage
+  For more information read manual at https://docs.google.com/document/pub?id=1_jsxhMNzMzy4d2d_byAd3n6Szg5gEcqG_Sf7w9tEqWw (not last version but comprehensive description of approach)
+
+## Basic usage as a command-line tool
+  MacroAPE have 6 command line tools:
+  
+### Tools for calculating thresholds and pvalues:
+  * find_threshold \<PWM file\> [-p \<pvalue\> (by default: 0.0005)]
+  * find_pvalue \<PWM file\> \<threshold\>
+  
+### Tools for evaluating Jaccard similarity measure in the best alignment and in certain alignment:
+  * eval_similarity \<first PWM file\> \<second PWM file\>
+  * eval_alignment \<first PWM file\> \<second PWM file\> \<shift of second matrix\> \<orientation of second matrix(direct|revcomp)\>
+  
+### Tools for looking through collection for the motifs most similar to a query motif
+  * preprocess_collection \<folder with motif files\> [-o \<collection output file\>]
+  * scan_collection \<query PWM file\> \<collection file\>
+  
+  Also you can use -h option to print help for a tool in console.
+  There are lots of different command line options. Most useful option is -d <discretization=1|10|100|1000>. You can vary precision/speed rate by specifing a discretization. For more information look through a manual.
+
+## Basic usage in your code
+    require 'macroape'
+    background = [1,1,1,1]
+    discretization = 10
+    first_pwm_matrix = [[1,2,3,4], [1,2,3,4], [4,1,2,3,], [5,3,2,4], [4,1,2,3], [7,8,9,11]]
+    pwm_first = PWM::SingleMatrix.new(first_pwm_matrix).with_background(background).discrete(discretization)
+    pwm_second = PWM::SingleMatrix.load_pat('another_pwm.pat').with_background(background).discrete(discretization)
+    cmp = PWMCompare::PWMCompare.new(pwm_first, pwm_second)
+    first_threshold = pwm_first.threshold(pvalue)
+    second_threshold = pwm_second.threshold(pvalue)
+    similarity_info = cmp.jaccard(first_threshold, second_threshold)
+    puts "Jaccard similarity: #{similarity_info[:similarity]}"
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+Copyright (c) 2011-2012 Ilya Vorontsov, Ivan Kulakovskiy, Vsevolod Makeev

data/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+desc 'Test all functionality of gem executables'
+task :test do
+  system("ruby test/macroape_test.rb")
+end

data/bin/eval_alignment

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require 'macroape/exec/eval_alignment.rb'

data/bin/eval_similarity

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require 'macroape/exec/eval_similarity.rb'

data/bin/find_pvalue

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require 'macroape/exec/find_pvalue.rb'

data/bin/find_threshold

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require 'macroape/exec/find_threshold.rb'

data/bin/preprocess_collection

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require 'macroape/exec/preprocess_collection.rb'

data/bin/scan_collection

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require 'macroape/exec/scan_collection.rb'

data/lib/macroape/aligned_pair_intersection.rb

@@ -0,0 +1,136 @@
+module PWMCompare
+  module AlignedPairIntersection
+
+    def counts_for_two_matrices(threshold_first, threshold_second)
+      if first.probabilities == second.probabilities
+        if first.probabilities == [1,1,1,1]
+          common_words_for_two_matrices(threshold_first, threshold_second)
+        else
+          counts_for_two_matrices_with_same_probabilities(threshold_first, threshold_second) 
+        end
+      else
+        counts_for_two_matrices_with_different_probabilities(threshold_first, threshold_second) 
+      end
+    end
+  
+    def counts_for_two_matrices_with_different_probabilities(threshold_first, threshold_second)
+      scores = { 0 => {0 => [1,1]} } # scores_on_first_pwm, scores_on_second_pwm --> count_on_first_probabilities, count_on_second_probabilities
+      result_first = 0.0
+      result_second = 0.0
+      length.times do |column|    
+        ending_weight_first =  first.sum_of_probabilities ** (length - column - 1)
+        ending_weight_second = second.sum_of_probabilities ** (length - column - 1)
+        already_enough_first  = threshold_first  - first.worst_suffix[column + 1]
+        already_enough_second = threshold_second - second.worst_suffix[column + 1]
+        least_sufficient_first  = threshold_first  - first.best_suffix[column + 1]
+        least_sufficient_second = threshold_second - second.best_suffix[column + 1]
+
+        new_scores = Hash.new{|h,k| h[k]=Hash.new{|h2,k2| h2[k2]=[0,0]}}
+        scores.each do |score_first, second_scores|
+          second_scores.each do |score_second, count|
+            4.times do |letter|          
+              new_score_first = score_first + first.matrix[column][letter]
+              if new_score_first >= already_enough_first 
+                new_score_second = score_second + second.matrix[column][letter]
+                if new_score_second >= already_enough_second
+                  result_first += count[0] * first.probabilities[letter] * ending_weight_first
+                  result_second += count[1] * second.probabilities[letter] * ending_weight_second
+                elsif new_score_second >= least_sufficient_second 
+                  new_scores[new_score_first][new_score_second][0] += count[0] * first.probabilities[letter]
+                  new_scores[new_score_first][new_score_second][1] += count[1] * second.probabilities[letter]
+                end
+              elsif new_score_first >= least_sufficient_first
+                new_score_second = score_second + second.matrix[column][letter]
+                if new_score_second >= least_sufficient_second
+                  new_scores[new_score_first][new_score_second][0] += count[0] * first.probabilities[letter]
+                  new_scores[new_score_first][new_score_second][1] += count[1] * second.probabilities[letter]
+                end
+              end
+            end
+          end
+        end
+        raise 'Hash overflow in PWMCompare::AlignedPairIntersection#counts_for_two_matrices_with_different_probabilities' if new_scores.inject(0){|sum,hsh|sum+hsh.size} > MaxHashSize
+        scores = new_scores
+      end
+      [result_first, result_second]
+    end
+    
+    def counts_for_two_matrices_with_same_probabilities(threshold_first, threshold_second)
+      scores = { 0 => {0 => 1} } # scores_on_first_pwm, scores_on_second_pwm --> count_on_first_probabilities, count_on_second_probabilities
+      result = 0.0
+      probabilities = first.probabilities
+      length.times do |column|    
+        ending_weight =  first.sum_of_probabilities ** (length - column - 1)
+        already_enough_first  = threshold_first  - first.worst_suffix[column + 1]
+        already_enough_second = threshold_second - second.worst_suffix[column + 1]
+        least_sufficient_first  = threshold_first  - first.best_suffix[column + 1]
+        least_sufficient_second = threshold_second - second.best_suffix[column + 1]
+
+        new_scores = Hash.new{|h,k| h[k]=Hash.new{|h2,k2| h2[k2]=0} }
+        scores.each do |score_first, second_scores|
+          second_scores.each do |score_second, count|
+            4.times do |letter|          
+              new_score_first = score_first + first.matrix[column][letter]
+              if new_score_first >= already_enough_first 
+                new_score_second = score_second + second.matrix[column][letter]
+                if new_score_second >= already_enough_second
+                  result += count * probabilities[letter] * ending_weight
+                elsif new_score_second >= least_sufficient_second 
+                  new_scores[new_score_first][new_score_second] += count * probabilities[letter]
+                end
+              elsif new_score_first >= least_sufficient_first
+                new_score_second = score_second + second.matrix[column][letter]
+                if new_score_second >= least_sufficient_second
+                  new_scores[new_score_first][new_score_second] += count * probabilities[letter]
+                end
+              end
+            end
+          end
+        end
+        raise 'Hash overflow in PWMCompare::AlignedPairIntersection#counts_for_two_matrices_with_same_probabilities' if new_scores.inject(0){|sum,hsh|sum+hsh.size} > MaxHashSize
+        scores = new_scores
+      end
+      [result, result]
+    end
+    
+    
+    def common_words_for_two_matrices(threshold_first, threshold_second)
+      scores = { 0 => {0 => 1} } # scores_on_first_pwm, scores_on_second_pwm --> count_on_first_probabilities, count_on_second_probabilities
+      result = 0
+      length.times do |column|    
+        ending_weight =  4 ** (length - column - 1)
+        already_enough_first  = threshold_first  - first.worst_suffix[column + 1]
+        already_enough_second = threshold_second - second.worst_suffix[column + 1]
+        least_sufficient_first  = threshold_first  - first.best_suffix[column + 1]
+        least_sufficient_second = threshold_second - second.best_suffix[column + 1]
+
+        new_scores = Hash.new{|h,k| h[k]=Hash.new{|h2,k2| h2[k2]=0} }
+        scores.each do |score_first, second_scores|
+          second_scores.each do |score_second, count|
+            4.times do |letter|          
+              new_score_first = score_first + first.matrix[column][letter]
+              if new_score_first >= already_enough_first 
+                new_score_second = score_second + second.matrix[column][letter]
+                if new_score_second >= already_enough_second
+                  result += count * ending_weight
+                elsif new_score_second >= least_sufficient_second 
+                  new_scores[new_score_first][new_score_second] += count
+                end
+              elsif new_score_first >= least_sufficient_first
+                new_score_second = score_second + second.matrix[column][letter]
+                if new_score_second >= least_sufficient_second
+                  new_scores[new_score_first][new_score_second] += count
+                end
+              end
+            end
+          end
+        end
+        
+        raise 'Hash overflow in PWMCompare::AlignedPairIntersection#common_words_for_two_matrices' if defined? MaxHashSize and new_scores.inject(0){|sum,hsh|sum+hsh.size} > MaxHashSize
+        scores = new_scores
+      end
+      [result, result]
+    end
+    
+  end
+end

data/lib/macroape/aligned_pair_metrics.rb

@@ -0,0 +1,24 @@
+module PWMCompare
+  module AlignedPairMetrics
+    def jaccard(first_threshold, second_threshold)
+      f = first.counts_by_thresholds(first_threshold).first
+      s = second.counts_by_thresholds(second_threshold).first
+      if f == 0 or s == 0
+        return {similarity: -1, tanimoto: -1, recognized_by_both: 0,
+              recognized_by_first: f,
+              recognized_by_second: s,
+            }
+      end
+      
+      intersect = counts_for_two_matrices(first_threshold, second_threshold)
+      intersect = Math.sqrt(intersect[0] * intersect[1])
+      union = f + s - intersect
+      similarity = intersect.to_f / union
+      { similarity: similarity,
+        tanimoto: 1.0 - similarity,
+        recognized_by_both: intersect,
+        recognized_by_first: f,
+        recognized_by_second: s }
+    end
+  end
+end

data/lib/macroape/aligned_pair_transformations.rb

@@ -0,0 +1,23 @@
+module PWMCompare
+  module AlignedPairTransformations
+  
+    #def discrete(rate)
+    #  PWMCompareAligned.new(first.discrete(rate), second.discrete(rate))
+    #end
+
+    def sort_pair_of_matrices_by(&block)
+      mat = first.pwm.zip(second.pwm).sort_by(&block).transpose
+      PWMCompareAligned.new(SinglePWM(mat[0],first.probabilities), SinglePWM(mat[1], second.probabilities))
+    end
+    def sort_decreasing_max
+      PWMCompareAligned.new(*sort_pair_of_matrices_by{|col_pair| -col_pair[0].max} )
+    end
+    def sort_increasing_min
+      PWMCompareAligned.new(*sort_pair_of_matrices_by{|col_pair| col_pair[0].min} )
+    end
+    def permute_columns(permutation_index)
+      PWMCompareAligned.new(first.permute(permutation_index), second.permute(permutation_index))
+    end
+  
+  end
+end

data/lib/macroape/collection.rb

@@ -0,0 +1,15 @@
+module PWM
+  class Collection
+    attr_reader :rough_discretization, :precise_discretization, :background, :pvalues, :pwms, :infos
+    def initialize(rough_discretization, precise_discretization, background, pvalues)
+      @rough_discretization, @precise_discretization, @background, @pvalues = rough_discretization, precise_discretization, background, pvalues
+      @pwms={}
+      @infos={}
+    end
+    def add_pwm(pwm,info)
+      #@pwms[pwm] = info
+      @pwms[pwm.name] = pwm
+      @infos[pwm.name] = info
+    end
+  end
+end

data/lib/macroape/count_by_threshold.rb

@@ -0,0 +1,34 @@
+module PWM
+  module CountByThreshold
+    def counts_by_thresholds(*thresholds)
+      scores = calculate_count_distribution_after_threshold(thresholds.min)
+=begin
+       thresholds.map{ |threshold|
+       #scores.select{|score,count| score >= threshold}.map{|score,count| count}.inject(0){|sum,val|sum+val}
+        scores.inject(0){|sum,(score,count)|  (score >= threshold) ? sum + count : sum}
+      }
+=end
+      s_thr= thresholds.map.with_index{|threshold,index|[threshold,index]}.sort_by{|threshold,index| threshold}
+      
+      cnt = 0
+      thr_cnts=[]
+      
+      scores.sort.reverse.each do |score,count|
+        while !s_thr.empty? and score < s_thr.last[0]
+          thr_cnts.push(cnt)
+          s_thr.pop
+        end
+        cnt += count
+      end
+      s_thr = thresholds.map.with_index{|threshold,index|[threshold,index]}.sort_by{|threshold,index| threshold}
+      while thr_cnts.size < s_thr.size
+        thr_cnts.push(cnt)
+      end
+      s_thr.reverse.zip(thr_cnts).sort_by{|(threshold,index), count| index}.map{|(threshold,index), count| count.to_f}
+    end
+
+    def pvalue_by_threshold(threshold)
+      counts_by_thresholds(threshold).first / number_of_words
+    end
+  end
+end

data/lib/macroape/exec/eval_alignment.rb

@@ -0,0 +1,141 @@
+help_string = %q{
+Command-line format:
+ruby eval_alignment.rb <1st matrix pat-file> <2nd matrix pat-file> <shift> <orientation(direct/revcomp)> [options]
+type <1st matrix pat-file> <2nd matrix pat-file> | ruby eval_alignment.rb .stdin .stdin <shift> <orientation(direct/revcomp)> [options]
+     or in linux
+cat <1st matrix pat-file> <2nd matrix pat-file> | ruby eval_alignment.rb .stdin .stdin <shift> <orientation(direct/revcomp)> [options]
+
+Options:
+  [-p <P-value>]
+  [-d <discretization level>]
+  [-b <background probabilities, ACGT - 4 numbers, space-delimited, sum should be equal to 1>]
+
+Output format:
+  <jaccard similarity coefficient>
+  <number of words recognized by both 1st and 2nd matrices | probability to draw a word recognized by both 1st and 2nd matrices> <length of the given alignment>
+  <aligned 1st matrix>
+  <aligned 2nd matrix>
+  <shift> <orientation>
+ 
+Examples:  
+  ruby eval_alignment.rb motifs/KLF4_f2.pat motifs/SP1_f1.pat -1 direct -p 0.0005 -d 100 -b 0.4 0.3 0.2 0.1
+     or on windows 
+  type motifs/SP1.pat | ruby eval_alignment.rb motifs/KLF4.pat .stdin 0 revcomp -p 0.0005 -d 100 -b 0.4 0.3 0.2 0.1
+     or in linux
+  cat motifs/KLF4.pat motifs/SP1.pat | ruby eval_alignment.rb .stdin .stdin 3 direct -p 0.0005 -d 100 -b 0.4 0.3 0.2 0.1
+}
+
+require 'macroape'
+
+if ARGV.empty? or ARGV.include? '-h' or ARGV.include? '-help' or ARGV.include? '--help' or ARGV.include? '--h'
+  STDERR.puts help_string
+  exit
+end
+
+pvalue = 0.0005
+discretization = 10
+
+first_background = [1,1,1,1]
+second_background = [1,1,1,1]
+
+begin 
+  first_file = ARGV.shift
+  second_file = ARGV.shift
+  
+  shift = ARGV.shift
+  orientation = ARGV.shift
+  
+  raise "You'd specify two input sources (each is filename or .stdin)" unless first_file and second_file
+  raise 'You\'d specify shift' unless shift
+  raise 'You\'d specify orientation' unless orientation
+  
+  shift = shift.to_i
+  orientation = orientation.to_sym
+  
+  case orientation
+    when :direct
+      reverse = false
+    when :revcomp
+      reverse = true
+    else
+      raise 'Unknown orientation(direct/revcomp)'
+  end
+  
+
+  until ARGV.empty?
+    case ARGV.shift
+      when '-p'
+        pvalue = ARGV.shift.to_f
+      when '-d'
+        discretization = ARGV.shift.to_f
+      when '-m'
+        PWM::MaxHashSize = ARGV.shift.to_f
+      when '-md'
+        PWMCompare::MaxHashSize = ARGV.shift.to_f
+      when '-b'
+        second_background = first_background = ARGV.shift(4).map(&:to_f)
+      when '-b1'
+        first_background = ARGV.shift(4).map(&:to_f)
+      when '-b2'
+        second_background = ARGV.shift(4).map(&:to_f)
+    end
+  end
+  raise 'background should be symmetric' unless first_background == first_background.reverse
+  raise 'background should be symmetric: p(A)=p(T) and p(G) = p(C)' unless second_background == second_background.reverse
+
+  
+  PWM::MaxHashSize = 1000000 unless defined? PWM::MaxHashSize
+  PWMCompare::MaxHashSize = 1000 unless defined? PWMCompare::MaxHashSize
+  
+  if first_file == '.stdin' || second_file == '.stdin'
+    r_stream, w_stream = IO.pipe
+    STDIN.readlines.each{|line| w_stream.write(line)}
+    w_stream.close
+  end
+  
+  if first_file == '.stdin'
+    r_stream, w_stream, extracted_pwm = extract_pwm(r_stream, w_stream)
+    pwm_first = PWM::SingleMatrix.load_from_line_array(extracted_pwm).with_background(first_background).discrete(discretization)
+  else
+    raise "Error! File #{first_file} don't exist" unless File.exist?(first_file)
+    pwm_first = PWM::SingleMatrix.load_pat(first_file).with_background(first_background).discrete(discretization)
+  end
+  
+  if second_file == '.stdin'
+    r_stream, w_stream, extracted_pwm = extract_pwm(r_stream, w_stream)
+    pwm_second = PWM::SingleMatrix.load_from_line_array(extracted_pwm).with_background(second_background).discrete(discretization)
+  else
+    raise "Error! File #{second_file} don't exist" unless File.exist?(second_file)
+    pwm_second = PWM::SingleMatrix.load_pat(second_file).with_background(second_background).discrete(discretization)
+  end
+  
+  r_stream.close if first_file == '.stdin' || second_file == '.stdin'
+  
+  
+  pwm_second = pwm_second.reverse_complement if reverse
+  
+  first_pwm_alignment = '.' * [-shift, 0].max + '>' * pwm_first.length
+  second_pwm_alignment = '.' * [shift, 0].max + (orientation == :direct ? '>' : '<') * pwm_second.length
+  overlap = [pwm_first.length + [-shift,0].max, pwm_second.length + [shift,0].max].min - shift.abs
+  alignment_length = [first_pwm_alignment.length, second_pwm_alignment.length].max
+  (first_pwm_alignment.length...alignment_length).each{|i| first_pwm_alignment[i] = '.'}
+  (second_pwm_alignment.length...alignment_length).each{|i| second_pwm_alignment[i] = '.'}
+
+  cmp = PWMCompare::PWMCompareAligned.new(pwm_first.left_augment([-shift,0].max), 
+                              pwm_second.left_augment([shift,0].max))
+
+  first_threshold = pwm_first.threshold(pvalue)
+  second_threshold = pwm_second.threshold(pvalue)
+
+  info = cmp.jaccard(first_threshold, second_threshold).merge(
+    text: "#{first_pwm_alignment}\n#{second_pwm_alignment}",
+    shift: shift,
+    orientation: orientation,
+    overlap: overlap,
+    alignment_length: alignment_length)
+  
+  puts "#{info[:similarity]}\n#{info[:recognized_by_both]}\t#{info[:alignment_length]}\n#{info[:text]}\n#{info[:shift]}\t#{info[:orientation]}"
+  
+rescue => err
+  STDERR.puts "\n#{err}\n#{err.backtrace.first(5).join("\n")}\n\nUse -help option for help\n"
+end

data/lib/macroape/exec/eval_similarity.rb

@@ -0,0 +1,107 @@
+help_string = %q{
+Command-line format:
+ruby eval_similarity.rb <1st matrix pat-file> <2nd matrix pat-file> [options]
+     or on windows
+type <1st matrix pat-file> <2nd matrix pat-file> | ruby eval_similarity.rb .stdin .stdin [options]
+     or in linux
+cat <1st matrix pat-file> <2nd matrix pat-file> | ruby eval_similarity.rb .stdin .stdin [options]
+
+Options:
+  [-p <P-value>]
+  [-d <discretization level>]
+  [-b <background probabilities, ACGT - 4 numbers, space-delimited, sum should be equal to 1>]
+
+Output has format:
+  <jaccard similarity coefficient>
+  <number of words recognized by both 1st and 2nd matrices | probability to draw a word recognized by both 1st and 2nd matrices> <length of the optimal alignment>
+  <optimal alignment, the 1st matrix>
+  <optimal alignment, the 2nd matrix>
+  <shift> <orientation>
+ 
+Examples:  
+  ruby eval_similarity.rb motifs/KLF4.pat motifs/SP1.pat -p 0.0005 -d 100 -b 0.4 0.3 0.2 0.1
+     or on windows 
+  type motifs/SP1.pat | ruby eval_similarity.rb motifs/KLF4.pat .stdin -p 0.0005 -d 100 -b 0.4 0.3 0.2 0.1
+     or in linux
+  cat motifs/KLF4.pat motifs/SP1.pat | ruby eval_similarity.rb .stdin .stdin -p 0.0005 -d 100 -b 0.4 0.3 0.2 0.1
+}
+
+require 'macroape'
+
+if ARGV.empty? or ARGV.include? '-h' or ARGV.include? '-help' or ARGV.include? '--help' or ARGV.include? '--h'
+  STDERR.puts help_string
+  exit
+end
+
+pvalue = 0.0005
+discretization = 10
+
+first_background = [1,1,1,1]
+second_background = [1,1,1,1]
+
+begin 
+  first_file = ARGV.shift
+  second_file = ARGV.shift
+  raise "You'd specify two input sources (each is filename or .stdin)" unless first_file and second_file
+
+  until ARGV.empty?
+    case ARGV.shift
+      when '-p'
+        pvalue = ARGV.shift.to_f
+      when '-d'
+        discretization = ARGV.shift.to_f
+      when '-m'
+        PWM::MaxHashSize = ARGV.shift.to_f
+      when '-md'
+        PWMCompare::MaxHashSize = ARGV.shift.to_f
+      when '-b'
+        second_background = first_background = ARGV.shift(4).map(&:to_f)
+      when '-b1'
+        first_background = ARGV.shift(4).map(&:to_f)
+      when '-b2'
+        second_background = ARGV.shift(4).map(&:to_f)      
+    end
+  end
+  raise 'background should be symmetric: p(A)=p(T) and p(G) = p(C)' unless first_background == first_background.reverse
+  raise 'background should be symmetric: p(A)=p(T) and p(G) = p(C)' unless second_background == second_background.reverse
+  
+  PWM::MaxHashSize = 1000000 unless defined? PWM::MaxHashSize
+  PWMCompare::MaxHashSize = 1000 unless defined? PWMCompare::MaxHashSize
+  
+  
+  if first_file == '.stdin' || second_file == '.stdin'
+    r_stream, w_stream = IO.pipe
+    STDIN.readlines.each{|line| w_stream.write(line)}
+    w_stream.close
+  end
+  
+  if first_file == '.stdin'
+    r_stream, w_stream, extracted_pwm = extract_pwm(r_stream, w_stream)
+    pwm_first = PWM::SingleMatrix.load_from_line_array(extracted_pwm).with_background(first_background).discrete(discretization)
+  else
+    raise "Error! File #{first_file} don't exist" unless File.exist?(first_file)
+    pwm_first = PWM::SingleMatrix.load_pat(first_file).with_background(first_background).discrete(discretization)
+  end
+  
+  if second_file == '.stdin'
+    r_stream, w_stream, extracted_pwm = extract_pwm(r_stream, w_stream)
+    pwm_second = PWM::SingleMatrix.load_from_line_array(extracted_pwm).with_background(second_background).discrete(discretization)
+  else
+    raise "Error! File #{second_file} don't exist" unless File.exist?(second_file)
+    pwm_second = PWM::SingleMatrix.load_pat(second_file).with_background(second_background).discrete(discretization)
+  end
+  
+  r_stream.close if first_file == '.stdin' || second_file == '.stdin'
+
+  cmp = PWMCompare::PWMCompare.new(pwm_first, pwm_second)
+
+  first_threshold = pwm_first.threshold(pvalue)
+  second_threshold = pwm_second.threshold(pvalue)
+
+  info = cmp.jaccard(first_threshold, second_threshold)
+  
+  puts "#{info[:similarity]}\n#{info[:recognized_by_both]}\t#{info[:alignment_length]}\n#{info[:text]}\n#{info[:shift]}\t#{info[:orientation]}"
+  
+rescue => err
+  STDERR.puts "\n#{err}\n#{err.backtrace.first(5).join("\n")}\n\nUse -help option for help\n"
+end