macroape 4.0.2 → 4.1.0

data/benchmark/similarity_benchmark.rb

@@ -1,53 +1,53 @@
-require_relative 'benchmark_helper'
-
-class TaskToBenchmark
-  def setup
-    @matrix_first = "KLF4_f2.xml
-      0.30861857265872605 -2.254321000121579 0.13505703522674192 0.3285194224375633
-      -1.227018967707036 -4.814127713368663 1.3059890687390967 -4.908681463544344
-      -2.443469374521196 -4.648238485031404 1.3588686548279805 -4.441801801188402
-      -2.7177827948276123 -3.8073538975356565 1.356272809724262 -3.504104725510225
-      -0.5563232977367343 0.5340697765121405 -3.61417723090579 0.5270259776377405
-      -1.8687622060887386 -4.381483976582316 1.337932245336098 -3.815629658877517
-      -2.045671123823928 -2.384975142213679 0.7198551207724355 0.5449254135616948
-      -1.373157530374372 -3.0063112097748217 1.285188335493552 -2.5026044231773543
-      -2.1030513122772208 -1.8941348100402244 1.249265758393991 -1.4284210948906104
-      -1.3277128628152939 0.8982415633049462 -0.8080773665408135 -0.18161647647456935
-      "
-
-    @matrix_second = "> SP1_f1
-    -0.24435707885585334  -0.6748234046937317  0.8657012535789861  -1.1060188862599292
-    -1.0631255752097801  -2.1119259694238686  1.0960627561110399  -0.6138563775211981
-    -0.387227623476054  -2.973985191321805  1.1807800242010371  -4.338927525031567
-    -4.563896055436894  -2.916163300253228  1.3684371349982631  -5.077972423609655
-    -2.2369752892820087  -3.719643631330185  1.3510439136452728  -4.8899306705082335
-    -0.07473964149330914  0.9449196547620103  -2.624685764808605  -0.851098348782244
-    -1.9643526491643326  -2.9784027708801153  1.3113096718240569  -2.3243342594990253
-    -4.015548413965584  -3.138426807809667  1.338748858978805  -2.0846739035376483
-    -0.4450938582835542  -2.2510053061629707  1.126543157436868  -1.7780413702431377
-    -1.1896356092245055  -1.2251832285630033  1.163676006374752  -1.6080243648157357
-    -0.5166047365590577  0.7641033353626651  -0.28626775700282125  -0.6825482097865606"
-
-    @pvalue = 0.0005
-    @discretization = 1
-    @first_background, @second_background = [1,1,1,1], [1,1,1,1]
-
-    @pwm_first = Bioinform::PWM.new(@matrix_first).set_parameters(background: @first_background).discrete(@discretization)
-    @pwm_second = Bioinform::PWM.new(@matrix_second).set_parameters(background: @second_background).discrete(@discretization)
-    @cmp = Macroape::PWMCompare.new(@pwm_first, @pwm_second)
-    @first_threshold = @pwm_first.threshold(@pvalue)
-    @second_threshold = @pwm_second.threshold(@pvalue)
-    self
-  end
-
-  def run
-    info = @cmp.jaccard(@first_threshold, @second_threshold)
-  end
-end
-
-benchmark_result = 100.times.collect do
-  task_to_benchmark = TaskToBenchmark.new.setup
-  Benchmark.measure{  task_to_benchmark.run }
-end.inject(&:+)
-
+require_relative 'benchmark_helper'
+
+class TaskToBenchmark
+  def setup
+    @matrix_first = "KLF4_f2.xml
+      0.30861857265872605 -2.254321000121579 0.13505703522674192 0.3285194224375633
+      -1.227018967707036 -4.814127713368663 1.3059890687390967 -4.908681463544344
+      -2.443469374521196 -4.648238485031404 1.3588686548279805 -4.441801801188402
+      -2.7177827948276123 -3.8073538975356565 1.356272809724262 -3.504104725510225
+      -0.5563232977367343 0.5340697765121405 -3.61417723090579 0.5270259776377405
+      -1.8687622060887386 -4.381483976582316 1.337932245336098 -3.815629658877517
+      -2.045671123823928 -2.384975142213679 0.7198551207724355 0.5449254135616948
+      -1.373157530374372 -3.0063112097748217 1.285188335493552 -2.5026044231773543
+      -2.1030513122772208 -1.8941348100402244 1.249265758393991 -1.4284210948906104
+      -1.3277128628152939 0.8982415633049462 -0.8080773665408135 -0.18161647647456935
+      "
+
+    @matrix_second = "> SP1_f1
+    -0.24435707885585334  -0.6748234046937317  0.8657012535789861  -1.1060188862599292
+    -1.0631255752097801  -2.1119259694238686  1.0960627561110399  -0.6138563775211981
+    -0.387227623476054  -2.973985191321805  1.1807800242010371  -4.338927525031567
+    -4.563896055436894  -2.916163300253228  1.3684371349982631  -5.077972423609655
+    -2.2369752892820087  -3.719643631330185  1.3510439136452728  -4.8899306705082335
+    -0.07473964149330914  0.9449196547620103  -2.624685764808605  -0.851098348782244
+    -1.9643526491643326  -2.9784027708801153  1.3113096718240569  -2.3243342594990253
+    -4.015548413965584  -3.138426807809667  1.338748858978805  -2.0846739035376483
+    -0.4450938582835542  -2.2510053061629707  1.126543157436868  -1.7780413702431377
+    -1.1896356092245055  -1.2251832285630033  1.163676006374752  -1.6080243648157357
+    -0.5166047365590577  0.7641033353626651  -0.28626775700282125  -0.6825482097865606"
+
+    @pvalue = 0.0005
+    @discretization = 1
+    @first_background, @second_background = [1,1,1,1], [1,1,1,1]
+
+    @pwm_first = Bioinform::PWM.new(@matrix_first).set_parameters(background: @first_background).discrete(@discretization)
+    @pwm_second = Bioinform::PWM.new(@matrix_second).set_parameters(background: @second_background).discrete(@discretization)
+    @cmp = Macroape::PWMCompare.new(@pwm_first, @pwm_second)
+    @first_threshold = @pwm_first.threshold(@pvalue)
+    @second_threshold = @pwm_second.threshold(@pvalue)
+    self
+  end
+
+  def run
+    info = @cmp.jaccard(@first_threshold, @second_threshold)
+  end
+end
+
+benchmark_result = 100.times.collect do
+  task_to_benchmark = TaskToBenchmark.new.setup
+  Benchmark.measure{  task_to_benchmark.run }
+end.inject(&:+)
+
 puts benchmark_result

data/bin/align_motifs

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
-
-require_relative '../lib/macroape/cli/align_motifs'
-Macroape::CLI::AlignMotifs.main(ARGV)
+#!/usr/bin/env ruby
+
+require_relative '../lib/macroape/cli/align_motifs'
+Macroape::CLI::AlignMotifs.main(ARGV)

data/bin/eval_alignment

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
-
-require_relative '../lib/macroape/cli/eval_alignment'
-Macroape::CLI::EvalAlignment.main(ARGV)
+#!/usr/bin/env ruby
+
+require_relative '../lib/macroape/cli/eval_alignment'
+Macroape::CLI::EvalAlignment.main(ARGV)

data/bin/eval_similarity

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
-
-require_relative '../lib/macroape/cli/eval_similarity'
-Macroape::CLI::EvalSimilarity.main(ARGV)
+#!/usr/bin/env ruby
+
+require_relative '../lib/macroape/cli/eval_similarity'
+Macroape::CLI::EvalSimilarity.main(ARGV)

data/bin/find_pvalue

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
-
-require_relative '../lib/macroape/cli/find_pvalue'
-Macroape::CLI::FindPValue.main(ARGV)
+#!/usr/bin/env ruby
+
+require_relative '../lib/macroape/cli/find_pvalue'
+Macroape::CLI::FindPValue.main(ARGV)

data/bin/find_threshold

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
-
-require_relative '../lib/macroape/cli/find_threshold'
-Macroape::CLI::FindThreshold.main(ARGV)
+#!/usr/bin/env ruby
+
+require_relative '../lib/macroape/cli/find_threshold'
+Macroape::CLI::FindThreshold.main(ARGV)

data/bin/preprocess_collection

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
-
-require_relative '../lib/macroape/cli/preprocess_collection'
-Macroape::CLI::PreprocessCollection.main(ARGV)
+#!/usr/bin/env ruby
+
+require_relative '../lib/macroape/cli/preprocess_collection'
+Macroape::CLI::PreprocessCollection.main(ARGV)

data/bin/scan_collection

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
-
-require_relative '../lib/macroape/cli/scan_collection'
-Macroape::CLI::ScanCollection.main(ARGV)
+#!/usr/bin/env ruby
+
+require_relative '../lib/macroape/cli/scan_collection'
+Macroape::CLI::ScanCollection.main(ARGV)

data/lib/macroape.rb

@@ -1,11 +1,14 @@
-require_relative 'macroape/version'
-
-require_relative 'macroape/counting'
-require_relative 'macroape/aligned_pair_intersection'
-require_relative 'macroape/pwm_compare_aligned'
-require_relative 'macroape/pwm_compare'
-require_relative 'macroape/cli'
-
-module Macroape
-  # Your code goes here...
-end
+require_relative 'macroape/version'
+require 'bioinform'
+
+require_relative 'macroape/pwm_counting'
+require_relative 'macroape/aligned_pair_intersection'
+require_relative 'macroape/pwm_compare_aligned'
+require_relative 'macroape/pwm_compare'
+require_relative 'macroape/collection'
+require_relative 'macroape/motif_with_thresholds'
+require_relative 'macroape/cli'
+
+module Macroape
+  # Your code goes here...
+end

data/lib/macroape/aligned_pair_intersection.rb

@@ -1,62 +1,61 @@
-module Macroape
-  class PWMCompareAligned
-    # unoptimized version of this and related methods
-    def counts_for_two_matrices(threshold_first, threshold_second)
-      # just not to call method each time
-      first_background = first.background
-      second_background = second.background
-      unless first_background == second_background
-        first_result = get_counts(threshold_first, threshold_second) {|score,letter| first_background[letter] * score }
-        second_result = get_counts(threshold_first, threshold_second) {|score,letter| second_background[letter] * score }
-        return [first_result, second_result]
-      end
-      if first.background == [1,1,1,1]
-        result = get_counts(threshold_first, threshold_second) {|score,letter| score}
-        [result, result]
-      else
-        result = get_counts(threshold_first, threshold_second) {|score,letter| first_background[letter] * score }
-        [result, result]
-      end
-    end
-
-
-    # block has form: {|score,letter| contribution to count by `letter` with `score` }
-    def get_counts(threshold_first, threshold_second, &count_contribution_block)
-      # scores_on_first_pwm, scores_on_second_pwm --> count
-      scores = { 0 => {0 => 1} }
-      length.times do |column|
-        new_scores = recalc_score_hash(scores,
-                          first.matrix[column], second.matrix[column],
-                          threshold_first - first.best_suffix(column + 1),
-                          threshold_second - second.best_suffix(column + 1), &count_contribution_block)
-        scores.replace(new_scores)
-        if max_pair_hash_size && scores.inject(0){|sum,hsh|sum + hsh.size} > max_pair_hash_size
-          raise 'Hash overflow in Macroape::AlignedPairIntersection#counts_for_two_matrices_with_different_probabilities'
-        end
-      end
-      scores.inject(0.0){|sum,(score_first, hsh)| sum + hsh.inject(0.0){|sum,(score_second, count)| sum + count }}
-    end
-
-    # wouldn't work without count_contribution_block
-    def recalc_score_hash(scores, first_column, second_column, least_sufficient_first, least_sufficient_second)
-      new_scores = Hash.new{|h,k| h[k] = Hash.new(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_column[letter]
-            if new_score_first >= least_sufficient_first
-              new_score_second = score_second + second_column[letter]
-              if new_score_second >= least_sufficient_second
-                new_scores[new_score_first][new_score_second] += yield(count, letter)
-              end
-            end
-          end
-
-        end
-      end
-      new_scores
-    end
-
-  end
-end
+module Macroape
+  class PWMCompareAligned
+    # unoptimized version of this and related methods
+    def counts_for_two_matrices(threshold_first, threshold_second)
+      # just not to call method each time
+      first_background = first.background.counts
+      second_background = second.background.counts
+      unless first_background == second_background
+        first_result = get_counts(threshold_first, threshold_second) {|score,letter| first_background[letter] * score }
+        second_result = get_counts(threshold_first, threshold_second) {|score,letter| second_background[letter] * score }
+        return [first_result, second_result]
+      end
+      if first.background.wordwise?
+        result = get_counts(threshold_first, threshold_second) {|score,letter| score}
+        [result, result]
+      else
+        result = get_counts(threshold_first, threshold_second) {|score,letter| first_background[letter] * score }
+        [result, result]
+      end
+    end
+
+
+    # block has form: {|score,letter| contribution to count by `letter` with `score` }
+    def get_counts(threshold_first, threshold_second, &count_contribution_block)
+      # scores_on_first_pwm, scores_on_second_pwm --> count
+      scores = { 0 => {0 => 1} }
+      length.times do |column|
+        new_scores = recalc_score_hash(scores,
+                          first.matrix[column], second.matrix[column],
+                          threshold_first - first.best_suffix(column + 1),
+                          threshold_second - second.best_suffix(column + 1), &count_contribution_block)
+        scores.replace(new_scores)
+        if max_pair_hash_size && scores.inject(0){|sum,hsh|sum + hsh.size} > max_pair_hash_size
+          raise 'Hash overflow in Macroape::AlignedPairIntersection#counts_for_two_matrices_with_different_probabilities'
+        end
+      end
+      scores.inject(0.0){|sum,(score_first, hsh)| sum + hsh.inject(0.0){|sum,(score_second, count)| sum + count }}
+    end
+
+    # wouldn't work without count_contribution_block
+    def recalc_score_hash(scores, first_column, second_column, least_sufficient_first, least_sufficient_second)
+      new_scores = Hash.new{|h,k| h[k] = Hash.new(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_column[letter]
+            if new_score_first >= least_sufficient_first
+              new_score_second = score_second + second_column[letter]
+              if new_score_second >= least_sufficient_second
+                new_scores[new_score_first][new_score_second] += yield(count, letter)
+              end
+            end
+          end
+
+        end
+      end
+      new_scores
+    end
+  end
+end

data/lib/macroape/cli.rb

@@ -1,188 +1,191 @@
-require 'bioinform/support/strip_doc'
-
-class String
-  def snake_case
-    gsub(/[A-Z]+/){|big| "_#{big.downcase}" }.sub(/^_/,'')
-  end
-end
-
-class Module
-  def run_tool_cmd
-    if Macroape::STANDALONE
-      "ruby #{tool_name}.rb"
-    else
-      tool_name
-    end
-  end
-  def tool_name
-    self.name.split('::').last.snake_case
-  end
-end
-
-module Macroape
-  module CLI
-    class OutputInformation
-      def initialize(data = nil)
-        @table_parameter_descriptions = []
-
-        @parameter_descriptions = []
-        @parameter_value_infos = []
-
-        @resulting_value_descriptions = []
-        @resulting_value_infos = []
-
-        @table_headers = []
-        @table_rows = []
-        @table_rows_callbacks = []
-        @data = data
-        yield self  if block_given?
-      end
-
-      def parameters_info
-        [*@parameter_descriptions, *@parameter_value_infos]
-      end
-      def resulting_values_info
-        [*@resulting_value_descriptions, *@resulting_value_infos]
-      end
-      def result
-        [parameters_info, resulting_values_info, resulting_table].reject(&:empty?).map{|b|b.join("\n")}.join("\n#\n")
-        #[*parameters_info, '#', *resulting_values_info, '#', *resulting_table].join("\n")
-      end
-
-      def add_parameter(param_name, description, value, &block)
-        @parameter_descriptions << parameter_description_string(param_name, description)
-        @parameter_value_infos << "# #{param_name} = #{value}"
-      end
-
-      def add_resulting_value(param_name, description, value, &block)
-        @resulting_value_descriptions << parameter_description_string(param_name, description)
-        @resulting_value_infos << "#{param_name}\t#{value}"
-      end
-
-      def add_table_parameter(param_name, description, key_in_hash, &block)
-        @table_parameter_descriptions << parameter_description_string(param_name, description)
-        add_table_parameter_without_description(param_name, key_in_hash, &block)
-      end
-
-      def add_table_parameter_without_description(param_name, key_in_hash, &block)
-        @table_headers << param_name
-        @table_rows << key_in_hash
-        @table_rows_callbacks << block
-      end
-
-      def parameter_description_string(param_name, description)
-        "# #{param_name}: #{description}"
-      end
-
-      def table_content
-        @data.map{|info|
-          @table_rows.zip(@table_rows_callbacks).map{|row,callback| callback ? callback.call(info[row]) : info[row] }.join("\t")
-        }
-      end
-
-      def header_content
-        '# ' + @table_headers.join("\t")
-      end
-
-      def resulting_table
-        @data ? [*@table_parameter_descriptions, header_content, *table_content] : []
-      end
-
-      # printed only if it is not wordwise [1,1,1,1]
-      def background_parameter(param_name, description, value, &block)
-        add_parameter(param_name, description, value.join(','), &block)  unless value == [1,1,1,1]
-      end
-    end
-
-    module Helper
-
-      def self.similarity_info_string(info)
-        OutputInformation.new { |infos|
-          infos.add_parameter('V', 'discretization', info[:discretization] )
-          infos.add_parameter('P', 'requested P-value', info[:requested_pvalue])  unless info[:predefined_threshold_first] && info[:predefined_threshold_second]
-          infos.add_parameter('T1', 'threshold for the 1st matrix', info[:predefined_threshold_first] )  if info[:predefined_threshold_first]
-          infos.add_parameter('T2', 'threshold for the 2nd matrix', info[:predefined_threshold_second] )  if info[:predefined_threshold_second]
-          infos.add_parameter('PB', 'P-value boundary', info[:pvalue_boundary])
-          if info[:first_background] == info[:second_background]
-            infos.background_parameter('B', 'background', info[:first_background])
-          else
-            infos.background_parameter('B1', 'background for the 1st model', info[:first_background])
-            infos.background_parameter('B2', 'background for the 2nd model', info[:second_background])
-          end
-
-          infos.add_resulting_value('S', 'similarity', info[:similarity])
-          infos.add_resulting_value('D', 'distance (1-similarity)', info[:tanimoto])
-          infos.add_resulting_value('L', 'length of the alignment', info[:alignment_length])
-          infos.add_resulting_value('SH', 'shift of the 2nd PWM relative to the 1st', info[:shift])
-          infos.add_resulting_value('OR', 'orientation of the 2nd PWM relative to the 1st', info[:orientation])
-          infos.add_resulting_value('A1', 'aligned 1st matrix', info[:text].lines.to_a.first.strip )
-          infos.add_resulting_value('A2', 'aligned 2nd matrix', info[:text].lines.to_a.last.strip )
-          infos.add_resulting_value('W', 'number of words recognized by both models (model = PWM + threshold)', info[:recognized_by_both] )
-          infos.add_resulting_value('W1', 'number of words and recognized by the first model', info[:recognized_by_first] )
-          infos.add_resulting_value('P1', 'P-value for the 1st matrix', info[:real_pvalue_first] )
-          infos.add_resulting_value('T1', 'threshold for the 1st matrix', info[:threshold_first] )  unless info[:predefined_threshold_first]
-          infos.add_resulting_value('W2', 'number of words recognized by the 2nd model', info[:recognized_by_second] )
-          infos.add_resulting_value('P2', 'P-value for the 2nd matrix', info[:real_pvalue_second] )
-          infos.add_resulting_value('T2', 'threshold for the 2nd matrix', info[:threshold_second] )  unless info[:predefined_threshold_second]
-        }.result
-      end
-
-############################################
-
-      def self.threshold_infos_string(data, parameters)
-        OutputInformation.new(data) { |infos|
-          infos.add_parameter('V', 'discretization value', parameters[:discretization])
-          infos.add_parameter('PB', 'P-value boundary', parameters[:pvalue_boundary])
-          infos.background_parameter('B', 'background', parameters[:background])
-
-          infos.add_table_parameter('P', 'requested P-value', :expected_pvalue)
-          infos.add_table_parameter('AP', 'actual P-value', :real_pvalue)
-          infos.add_table_parameter('W', 'number of recognized words', :recognized_words)  if parameters[:background] == [1, 1, 1, 1]
-          infos.add_table_parameter('T', 'threshold', :threshold)
-        }.result
-      end
-
-############################################
-
-      def self.scan_collection_infos_string(data, parameters)
-        OutputInformation.new(data) { |infos|
-          infos.add_parameter('MS', 'minimal similarity to output', parameters[:cutoff])
-          infos.add_parameter('P', 'P-value', parameters[:pvalue])
-          infos.add_parameter('PB', 'P-value boundary', parameters[:pvalue_boundary])
-          if parameters[:precision_mode] == :precise
-            infos.add_parameter('VR', 'discretization value, rough', parameters[:rough_discretization])
-            infos.add_parameter('VP', 'discretization value, precise', parameters[:precise_discretization])
-            infos.add_parameter('MP', 'minimal similarity for the 2nd pass in \'precise\' mode', parameters[:minimal_similarity])
-          else
-            infos.add_parameter('V', 'discretization value', parameters[:rough_discretization])
-          end
-          infos.background_parameter('BQ', 'background for query matrix', parameters[:query_background])
-          infos.background_parameter('BC', 'background for collection', parameters[:collection_background])
-
-          infos.add_table_parameter_without_description('motif', :name)
-          infos.add_table_parameter_without_description('similarity', :similarity)
-          infos.add_table_parameter_without_description('shift', :shift)
-          infos.add_table_parameter_without_description('overlap', :overlap)
-          infos.add_table_parameter_without_description('orientation', :orientation)
-          if parameters[:precision_mode] == :precise
-            infos.add_table_parameter_without_description('precise mode', :precision_mode){|precision| precision == :precise ? '*' : '.' }
-          end
-        }.result
-      end
-
-############################################
-
-      def self.find_pvalue_info_string(data, parameters)
-        OutputInformation.new(data) {|infos|
-          infos.add_parameter('V', 'discretization value', parameters[:discretization])
-          infos.background_parameter('B', 'background', parameters[:background])
-
-          infos.add_table_parameter('T', 'threshold', :threshold)
-          infos.add_table_parameter('W', 'number of recognized words', :number_of_recognized_words)  if parameters[:background] == [1,1,1,1]
-          infos.add_table_parameter('P', 'P-value', :pvalue)
-        }.result
-      end
-
-    end
-  end
-end
+require 'bioinform/support/strip_doc'
+
+class String
+  def snake_case
+    gsub(/[A-Z]+/){|big| "_#{big.downcase}" }.sub(/^_/,'')
+  end
+end
+
+class Module
+  def run_tool_cmd
+    if Macroape::STANDALONE
+      "ruby #{tool_name}.rb"
+    else
+      tool_name
+    end
+  end
+  def tool_name
+    self.name.split('::').last.snake_case
+  end
+end
+
+module Macroape
+  module CLI
+    class OutputInformation
+      def initialize(data = nil)
+        @table_parameter_descriptions = []
+
+        @parameter_descriptions = []
+        @parameter_value_infos = []
+
+        @resulting_value_descriptions = []
+        @resulting_value_infos = []
+
+        @table_headers = []
+        @table_rows = []
+        @table_rows_callbacks = {}
+        @data = data
+        yield self  if block_given?
+      end
+
+      def parameters_info
+        [*@parameter_descriptions, *@parameter_value_infos]
+      end
+      def resulting_values_info
+        [*@resulting_value_descriptions, *@resulting_value_infos]
+      end
+      def result
+        [parameters_info, resulting_values_info, resulting_table].reject(&:empty?).map{|b|b.join("\n")}.join("\n#\n")
+        #[*parameters_info, '#', *resulting_values_info, '#', *resulting_table].join("\n")
+      end
+
+      def add_parameter(param_name, description, value, &block)
+        @parameter_descriptions << parameter_description_string(param_name, description)
+        @parameter_value_infos << "# #{param_name} = #{value}"
+      end
+
+      def add_resulting_value(param_name, description, value, &block)
+        @resulting_value_descriptions << parameter_description_string(param_name, description)
+        @resulting_value_infos << "#{param_name}\t#{value}"
+      end
+
+      def add_table_parameter(param_name, description, key_in_hash, &block)
+        @table_parameter_descriptions << parameter_description_string(param_name, description)
+        add_table_parameter_without_description(param_name, key_in_hash, &block)
+      end
+
+      def add_table_parameter_without_description(param_name, key_in_hash, &block)
+        @table_headers << param_name
+        @table_rows << key_in_hash
+        @table_rows_callbacks[key_in_hash] = block
+      end
+
+      def parameter_description_string(param_name, description)
+        "# #{param_name}: #{description}"
+      end
+
+      def table_content
+        @data.map{|info|
+          @table_rows.map{|row| @table_rows_callbacks[row] ? @table_rows_callbacks[row].call(info[row]) : info[row] }.join("\t")
+        }
+      end
+
+      def header_content
+        '# ' + @table_headers.join("\t")
+      end
+
+      def resulting_table
+        @data ? [*@table_parameter_descriptions, header_content, *table_content] : []
+      end
+
+      # printed only if it is not wordwise [1,1,1,1]
+      def background_parameter(param_name, description, value, &block)
+        if value.is_a?(Bioinform::Background)
+          add_parameter(param_name, description, value.to_s, &block)  unless value.wordwise?
+        else
+          add_parameter(param_name, description, value.join(','), &block)  unless value == [1,1,1,1]
+        end
+      end
+    end
+
+    module Helper
+
+      def self.similarity_info_string(info)
+        OutputInformation.new { |infos|
+          infos.add_parameter('V', 'discretization', info[:discretization] )
+          infos.add_parameter('P', 'requested P-value', info[:requested_pvalue])  unless info[:predefined_threshold_first] && info[:predefined_threshold_second]
+          infos.add_parameter('T1', 'threshold for the 1st matrix', info[:predefined_threshold_first] )  if info[:predefined_threshold_first]
+          infos.add_parameter('T2', 'threshold for the 2nd matrix', info[:predefined_threshold_second] )  if info[:predefined_threshold_second]
+          infos.add_parameter('PB', 'P-value boundary', info[:pvalue_boundary])
+          if info[:first_background] == info[:second_background]
+            infos.background_parameter('B', 'background', info[:first_background])
+          else
+            infos.background_parameter('B1', 'background for the 1st model', info[:first_background])
+            infos.background_parameter('B2', 'background for the 2nd model', info[:second_background])
+          end
+
+          infos.add_resulting_value('S', 'similarity', info[:similarity])
+          infos.add_resulting_value('D', 'distance (1-similarity)', info[:tanimoto])
+          infos.add_resulting_value('L', 'length of the alignment', info[:alignment_length])
+          infos.add_resulting_value('SH', 'shift of the 2nd PWM relative to the 1st', info[:shift])
+          infos.add_resulting_value('OR', 'orientation of the 2nd PWM relative to the 1st', info[:orientation])
+          infos.add_resulting_value('A1', 'aligned 1st matrix', info[:text].lines.to_a.first.strip )
+          infos.add_resulting_value('A2', 'aligned 2nd matrix', info[:text].lines.to_a.last.strip )
+          infos.add_resulting_value('W', 'number of words recognized by both models (model = PWM + threshold)', info[:recognized_by_both] )
+          infos.add_resulting_value('W1', 'number of words and recognized by the first model', info[:recognized_by_first] )
+          infos.add_resulting_value('P1', 'P-value for the 1st matrix', info[:real_pvalue_first] )
+          infos.add_resulting_value('T1', 'threshold for the 1st matrix', info[:threshold_first] )  unless info[:predefined_threshold_first]
+          infos.add_resulting_value('W2', 'number of words recognized by the 2nd model', info[:recognized_by_second] )
+          infos.add_resulting_value('P2', 'P-value for the 2nd matrix', info[:real_pvalue_second] )
+          infos.add_resulting_value('T2', 'threshold for the 2nd matrix', info[:threshold_second] )  unless info[:predefined_threshold_second]
+        }.result
+      end
+
+############################################
+
+      def self.threshold_infos_string(data, parameters)
+        OutputInformation.new(data) { |infos|
+          infos.add_parameter('V', 'discretization value', parameters[:discretization])
+          infos.add_parameter('PB', 'P-value boundary', parameters[:pvalue_boundary])
+          infos.background_parameter('B', 'background', parameters[:background])
+
+          infos.add_table_parameter('P', 'requested P-value', :expected_pvalue)
+          infos.add_table_parameter('AP', 'actual P-value', :real_pvalue)
+          infos.add_table_parameter('W', 'number of recognized words', :recognized_words)  if parameters[:background].wordwise?
+          infos.add_table_parameter('T', 'threshold', :threshold)
+        }.result
+      end
+
+############################################
+
+      def self.scan_collection_infos_string(data, parameters)
+        OutputInformation.new(data) { |infos|
+          infos.add_parameter('MS', 'minimal similarity to output', parameters[:cutoff])
+          infos.add_parameter('P', 'P-value', parameters[:pvalue])
+          infos.add_parameter('PB', 'P-value boundary', parameters[:pvalue_boundary])
+          if parameters[:precision_mode] == :precise
+            infos.add_parameter('VR', 'discretization value, rough', parameters[:rough_discretization])
+            infos.add_parameter('VP', 'discretization value, precise', parameters[:precise_discretization])
+            infos.add_parameter('MP', 'minimal similarity for the 2nd pass in \'precise\' mode', parameters[:minimal_similarity])
+          else
+            infos.add_parameter('V', 'discretization value', parameters[:rough_discretization])
+          end
+          infos.background_parameter('BQ', 'background for query matrix', parameters[:query_background])
+          infos.background_parameter('BC', 'background for collection', parameters[:collection_background])
+
+          infos.add_table_parameter_without_description('motif', :name)
+          infos.add_table_parameter_without_description('similarity', :similarity)
+          infos.add_table_parameter_without_description('shift', :shift)
+          infos.add_table_parameter_without_description('overlap', :overlap)
+          infos.add_table_parameter_without_description('orientation', :orientation)
+          if parameters[:precision_mode] == :precise
+            infos.add_table_parameter_without_description('precise mode', :precision_mode){|precision| precision == :precise ? '*' : '.' }
+          end
+        }.result
+      end
+
+############################################
+
+      def self.find_pvalue_info_string(data, parameters)
+        OutputInformation.new(data) {|infos|
+          infos.add_parameter('V', 'discretization value', parameters[:discretization])
+          infos.background_parameter('B', 'background', parameters[:background])
+
+          infos.add_table_parameter('T', 'threshold', :threshold)
+          infos.add_table_parameter('W', 'number of recognized words', :number_of_recognized_words)  if parameters[:background].wordwise?
+          infos.add_table_parameter('P', 'P-value', :pvalue)
+        }.result
+      end
+    end
+  end
+end