macroape 3.2.2

data/lib/macroape/exec/find_pvalue.rb

@@ -0,0 +1,80 @@
+help_string = %q{
+Command-line format:
+ruby find_pvalue.rb <pat-file> <threshold list> [options]
+        	or in linux 
+cat <pat-file> | ruby find_pvalue.rb .stdin <threshold> [options]
+ 	or on windows
+type <pat-file> | ruby find_pvalue.rb .stdin <threshold> [options]
+
+Options:
+  [-d <discretization level>]
+  [-b <background probabilities, ACGT - 4 numbers, space-delimited, sum should be equal to 1>]
+
+Output format:
+	threshold_1 count_1  pvalue_1
+	threshold_2 count_2  pvalue_2
+	threshold_3 count_3  pvalue_3
+The results are printed out in the same order as in the given threshold list.
+
+Examples:  
+  ruby find_pvalue.rb motifs/KLF4.pat 7.32 -d 1000 -b 0.2 0.3 0.2 0.3
+           or on windows
+  type motifs/KLF4.pat | ruby find_pvalue.rb .stdin 7.32 4.31 5.42
+           or in linux
+  cat motifs/KLF4.pat | ruby find_pvalue.rb .stdin 7.32 4.31 5.42
+}
+
+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
+
+discretization = 10000
+background = [1,1,1,1]
+thresholds = []
+begin 
+  filename = ARGV.shift
+
+  loop do
+    begin
+      Float(ARGV.first)
+      thresholds << ARGV.shift.to_f
+    rescue
+      raise StopIteration
+    end
+  end
+  
+  raise "No input. You'd specify input source: filename or .stdin" unless filename
+  raise 'You should specify at least one threshold' if thresholds.empty?
+  
+  until ARGV.empty?
+    case ARGV.shift
+      when '-b'
+        background = ARGV.shift(4).map(&:to_f)
+      when '-d'
+        discretization = ARGV.shift.to_f
+      when '-m'
+        PWM::MaxHashSize = ARGV.shift.to_f
+    end
+  end
+  PWM::MaxHashSize = 1000000 unless defined? PWM::MaxHashSize
+  
+  
+  if filename == '.stdin'
+    pwm = PWM::SingleMatrix.load_from_stdin(STDIN)
+  else
+    raise "Error! File #{filename} doesn't exist" unless File.exist?(filename)
+    pwm = PWM::SingleMatrix.load_pat(filename)
+  end
+  pwm = pwm.with_background(background)
+
+  counts = pwm.discrete(discretization).counts_by_thresholds(* thresholds.map{|count| count * discretization})
+  pvalues = counts.map{|count| count.to_f / pwm.number_of_words}
+  pvalues.zip(thresholds,counts).each{|pvalue,threshold,count|
+    puts "#{threshold}\t#{count}\t#{pvalue}"
+  }
+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/find_threshold.rb

@@ -0,0 +1,76 @@
+help_string = %q{
+Command-line format::
+ruby find_threshold.rb <pat-file> [options]
+        	or in linux
+cat <pat-file> | ruby find_threshold.rb .stdin [options]
+            or on windows
+type <pat-file> | ruby find_threshold.rb .stdin [options]
+
+Options:
+  [-p <list of P-values>]
+  [-d <discretization level>]
+  [-b <background probabilities, ACGT - 4 numbers, space-delimited, sum should be equal to 1>]
+
+Output format:
+ 	requested_pvalue_1 threshold_1 achieved_pvalue_1
+ 	requested_pvalue_2 threshold_2 achieved_pvalue_2
+	 
+	 
+Example:  
+  ruby find_threshold.rb motifs/KLF4.pat -p 0.001 0.0001 0.0005 -d 1000 -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
+
+background = [1,1,1,1]
+default_pvalues = [0.0005]
+discretization = 10000
+
+begin
+  filename = ARGV.shift
+  raise "No input. You'd specify input source: filename or .stdin" unless filename
+  
+  pvalues = []
+  until ARGV.empty?
+    case ARGV.shift
+      when '-b'
+        background = ARGV.shift(4).map(&:to_f)
+      when '-m'
+        PWM::MaxHashSize = ARGV.shift.to_f
+      when '-p'
+        loop do
+          begin
+            Float(ARGV.first)
+            pvalues << ARGV.shift.to_f
+          rescue
+            raise StopIteration
+          end
+        end
+      when '-d'
+        discretization = ARGV.shift.to_f
+      end
+  end
+  pvalues = default_pvalues if pvalues.empty?
+  
+  PWM::MaxHashSize = 1000000 unless defined? PWM::MaxHashSize
+  
+  if filename == '.stdin'
+    pwm = PWM::SingleMatrix.load_from_stdin(STDIN)
+  else
+    raise "Error! File #{filename} doesn't exist" unless File.exist?(filename)
+    pwm = PWM::SingleMatrix.load_pat(filename)
+  end
+  
+  pwm = pwm.with_background(background)
+  
+  pwm.discrete(discretization).thresholds(*pvalues) do |pvalue, threshold, real_pvalue|
+    puts "#{pvalue}\t#{threshold / discretization}\t#{real_pvalue}"
+  end
+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/preprocess_collection.rb

@@ -0,0 +1,94 @@
+help_string = %q{
+Command-line format:
+  ruby preprocess_collection.rb <folder with PWMs> [options]
+
+Options:
+  [-p <list of P-values>]
+  [-d <rough discretization> <precise discretization>]
+  [-b <background probabilities, ACGT - 4 numbers, space-delimited, sum should be equal to 1>]
+  [-o <output file>]
+  [--silent] - don't show current progress information during scan (by default this information's written into stderr)
+
+The tool stores preprocessed PWM collection to the specified YAML-file.
+ 
+Example:
+  ruby preprocess_collection.rb ./motifs -p 0.001 0.0005 0.0001 -d 1 10 -b 0.2 0.3 0.2 0.3 -o collection.yaml
+}
+
+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
+
+default_pvalues = [0.0005]
+background = [1,1,1,1]
+rough_discretization = 1
+precise_discretization = 10
+output_file =  'collection.yaml'
+
+begin
+  folder = ARGV.shift
+  raise "No input. You'd specify folder with pat-files" unless folder
+  raise "Error! Folder #{folder} doesn't exist" unless Dir.exist?(folder)
+  
+  pvalues = []
+  silent = false
+  until ARGV.empty?
+    case ARGV.shift
+      when '-b'
+        background = ARGV.shift(4).map(&:to_f)
+        raise 'background should be symmetric: p(A)=p(T) and p(G) = p(C)' unless background == background.reverse
+      when '-p'
+        loop do
+          begin
+            Float(ARGV.first)
+            pvalues << ARGV.shift.to_f
+          rescue
+            raise StopIteration
+          end
+        end
+      when '-d'
+        rough_discretization, precise_discretization = ARGV.shift(2).map(&:to_f).sort
+      when '-o'
+        output_file = ARGV.shift
+      when '-m'
+        PWM::MaxHashSize = ARGV.shift.to_f
+      when '-md'
+        PWMCompare::MaxHashSize = ARGV.shift.to_f
+      when '--silent'
+        silent = true
+      end
+  end
+  pvalues = default_pvalues if pvalues.empty?
+  
+  PWM::MaxHashSize = 1000000 unless defined? PWM::MaxHashSize
+  PWMCompare::MaxHashSize = 1000 unless defined? PWMCompare::MaxHashSize
+
+  collection = PWM::Collection.new(rough_discretization, precise_discretization, background, pvalues)
+
+  current_dir = File.dirname(__FILE__)
+  Dir.glob(File.join(folder,'*')) do |filename|
+    STDERR.puts filename unless silent
+    pwm = PWM::SingleMatrix.load_pat(filename)
+    info = {rough: {}, precise: {}}
+    output = `ruby "#{File.join current_dir,'find_threshold.rb'}" #{filename} -p #{pvalues.join(' ')} -b #{background.join(' ')} -d #{rough_discretization}`.split("\n")
+    output.each do |line|
+      pvalue, threshold, real_pvalue = line.split.map(&:to_f)
+      info[:rough][pvalue] = threshold
+    end
+    
+    output = `ruby "#{File.join current_dir,'find_threshold.rb'}" #{filename} -p #{pvalues.join(' ')} -b #{background.join(' ')} -d #{precise_discretization}`.split("\n")
+    output.each do |line|
+      pvalue, threshold, real_pvalue = line.split.map(&:to_f)
+      info[:precise][pvalue] = threshold
+    end
+    collection.add_pwm(pwm, info)
+  end
+  File.open(output_file,'w') do |f|
+    f.puts(collection.to_yaml)
+  end
+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/scan_collection.rb

@@ -0,0 +1,124 @@
+help_string = %q{
+Command-line format:
+ruby scan_collection.rb <pat-file> <collection> [options]
+        or in linux
+cat <pat-file> | ruby scan_collection.rb .stdin <collection> [options]
+        or on windows
+type <pat-file> | ruby scan_collection.rb .stdin <collection> [options]
+
+Options:
+  [-p <P-value>]
+  [-c <similarity cutoff (minimal similarity to be included in output)> ] or [--all], '-c 0.05' by default
+  [--precise [<level, minimal similarity to check on a more precise discretization level on the second pass>]], off by default, '--precise 0.01' if level is not set
+  [--silent] - don't show current progress information during scan (by default this information's written into stderr)
+  
+Output format:
+ <name> <similarity jaccard index> <shift> <overlap> <orientation> * [in case that result calculated on the second pass(in precise mode)]
+    Attention! Name can contain whitespace characters. 
+    Attention! The shift and orientation are reported for the collection matrix relative to the query matrix.
+	 
+Example:  
+  ruby scan_collection.rb motifs/KLF4.pat collection.yaml -p 0.005
+            or in linux
+  cat motifs/KLF4.pat | ruby scan_collection.rb .stdin collection.yaml -p 0.005 --precise 0.03
+}
+
+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
+
+begin
+  filename = ARGV.shift
+  collection_file = ARGV.shift
+  raise "No input. You'd specify input source for pat: filename or .stdin" unless filename
+  raise "No input. You'd specify input file with collection" unless collection_file
+  raise "Collection file #{collection_file} doesn't exist" unless File.exist?(collection_file)
+  
+  pvalue = 0.0005
+  cutoff = 0.05 # minimal similarity to output
+  collection = YAML.load_file(collection_file)
+  background_query = collection.background
+
+  silent = false
+  precision_mode = :rough
+  until ARGV.empty?
+    case ARGV.shift
+      when '-bq'
+        background_query = ARGV.shift(4).map(&:to_f)
+        raise 'background should be symmetric: p(A)=p(T) and p(G) = p(C)' unless background_query == background_query.reverse
+      when '-p'
+        pvalue = ARGV.shift.to_f
+      when '-m'
+        PWM::MaxHashSize = ARGV.shift.to_f
+      when '-md'
+        PWMCompare::MaxHashSize = ARGV.shift.to_f
+      when '-c'
+        cutoff = ARGV.shift.to_f
+      when '--all'
+        cutoff = 0.0
+      when '--silent'
+        silent = true
+      when '--precise'
+        precision_mode = :precise
+        begin 
+          Float(ARGV.first)
+          minimal_similarity = ARGV.shift.to_f
+        rescue
+          minimal_similarity = 0.05
+        end
+    end
+  end
+  PWM::MaxHashSize = 1000000 unless defined? PWM::MaxHashSize
+  PWMCompare::MaxHashSize = 1000 unless defined? PWMCompare::MaxHashSize
+  
+  raise "Thresholds for pvalue #{pvalue} aren't presented in collection (#{collection.pvalues.join(', ')}). Use one of listed pvalues or recalculate the collection with needed pvalue" unless collection.pvalues.include? pvalue
+  
+  if filename == '.stdin'
+    query_pwm = PWM::SingleMatrix.load_from_stdin(STDIN)
+  else
+    raise "Error! File #{filename} doesn't exist" unless File.exist?(filename)
+    query_pwm = PWM::SingleMatrix.load_pat(filename)
+  end
+  
+  
+  query_pwm_rough = query_pwm.with_background(background_query).discrete(collection.rough_discretization)
+  query_pwm_precise = query_pwm.with_background(background_query).discrete(collection.precise_discretization)
+  
+  threshold = query_pwm_rough.threshold(pvalue)
+  threshold_precise = query_pwm_precise.threshold(pvalue)
+  
+  similarities = {}
+  precision_file_mode = {}
+  unnamed_index = 0
+  
+  collection.pwms.each_key do |name|
+    pwm = collection.pwms[name]
+    pwm_info = collection.infos[name]
+    STDERR.puts pwm.name unless silent
+    cmp = PWMCompare::PWMCompare.new(query_pwm_rough, pwm.with_background(collection.background).discrete(collection.rough_discretization))
+    info = cmp.jaccard(threshold, pwm_info[:rough][pvalue] * collection.rough_discretization)
+    name = pwm.name || "Unnamed #{unnamed_index += 1}"
+    precision_file_mode[name] = :rough
+    
+    if precision_mode == :precise and info[:similarity] >= minimal_similarity
+      cmp = PWMCompare::PWMCompare.new(query_pwm_precise, pwm.with_background(collection.background).discrete(collection.precise_discretization))
+      info = cmp.jaccard(threshold_precise, pwm_info[:precise][pvalue] * collection.precise_discretization)
+      precision_file_mode[name] = :precise
+    end
+    similarities[name] = info
+  end
+  
+  puts "#pwm\tsimilarity\tshift\toverlap\torientation"
+  similarities.sort_by do |name, info|
+    info[:similarity]
+  end.reverse.each do |name, info|
+    precision_text = (precision_file_mode[name] == :precise) ? "\t*" : ""
+    puts "#{name}\t#{info[:similarity]}\t#{info[:shift]}\t#{info[:overlap]}\t#{info[:orientation]}#{precision_text}" if info[:similarity] >= cutoff
+  end
+  
+rescue => err
+  STDERR.puts "\n#{err}\n#{err.backtrace.first(5).join("\n")}\n\nUse -help option for help\n"
+end

data/lib/macroape/extract_pwm.rb

@@ -0,0 +1,32 @@
+# r_stream, w_stream - supposed to be a pipe. Data's read from r_stream, pwm's extracted, remaining data pushed back to w_stream
+#  ... --> w_stream --> r_stream --> data
+#              ^                       |
+#              |                       v
+#             ...  <--  w_stream  <-- ... --> extracted pwm
+def extract_pwm(r_stream, w_stream)
+  lines = r_stream.readlines
+  return [r_stream, w_stream, nil] if lines.empty?
+  
+  extracted_pwm = [lines.shift]
+  while extracted_pwm.last.chomp == ''
+    extracted_pwm = [lines.shift.strip]
+    return [r_stream, w_stream, nil] unless extracted_pwm.last
+  end
+  
+  r_stream.close
+  begin
+    until lines.empty? 
+      line = lines.shift
+      line.split.each{|x| Float(x) } # raises error if string is not a numeric
+      raise 'Not a PWM string (too little number of numbers - may be empty string or name of next pwm). PWM finished' if line.split.size < 4
+      extracted_pwm << line
+    end
+  rescue
+    lines.unshift(line)
+  end
+  new_r_stream, new_w_stream = IO.pipe
+  lines.each{|one_line| new_w_stream.write(one_line)}
+  new_w_stream.close
+  
+  [new_r_stream, new_w_stream, extracted_pwm]
+end

data/lib/macroape/gauss_estimation.rb

@@ -0,0 +1,30 @@
+module PWM
+  module GaussEstimation
+    def score_mean
+      bckgr = probabilities.map{|v| v.to_f / sum_of_probabilities}
+      matrix.inject(0.0){ |mean, col| mean + 4.times.inject(0.0){|sum,letter| sum + col[letter] * bckgr[letter]} }
+    end
+    def score_variance
+      bckgr = probabilities.map{|v| v.to_f / sum_of_probabilities}
+      matrix.inject(0.0) do |variance, col|
+        variance  + 4.times.inject(0.0) { |sum,letter| sum + col[letter]**2 * bckgr[letter] } -
+                    4.times.inject(0.0) { |sum,letter| sum + col[letter]    * bckgr[letter] }**2
+      end
+    end
+    def threshold_gauss_estimation(pvalue)
+      sigma = Math.sqrt(score_variance)
+      n_ = inverf2(1 - 2 * pvalue) * Math.sqrt(2)
+      score_mean + n_ * sigma
+    end
+    def inverf2(x)
+      sign = x < 0 ? -1 : 1
+      x = x.abs
+      a = 8 / (3*Math::PI) * (Math::PI-3) / (4-Math::PI)
+      part0 = ( 2/(Math::PI*a) + (Math.log(1-x*x)) / 2 )**2
+      part = -2 / (Math::PI * a) - Math.log(1-x*x)/2 + Math.sqrt(-1/a *
+      Math.log(1-x*x) + part0)
+      sign * Math.sqrt(part)
+    end   
+  end
+  
+end

data/lib/macroape/matrix_information.rb

@@ -0,0 +1,29 @@
+module PWM
+  module MatrixInformation
+    def length
+      @length ||= matrix.length
+    end
+    def best_score
+      @best_score ||= matrix.inject(0){|sum, col| sum + col.max}
+    end
+    def worst_score
+      @worst_score ||= matrix.inject(0){|sum, col| sum + col.min}
+    end
+    def best_suffix
+      return @best_suffix if @best_suffix
+      @best_suffix = Array.new(length + 1, 0) # best score of suffix s[i..l]
+      length.times{|i| @best_suffix[length - i - 1] = matrix[length - i - 1].max + @best_suffix[length - i] }
+      @best_suffix
+    end
+    def worst_suffix
+      return @worst_suffix if @worst_suffix
+      @worst_suffix = Array.new(length + 1, 0)
+      length.times{|i| @worst_suffix[length - i - 1] = matrix[length - i - 1].min + @worst_suffix[length - i] }
+      @worst_suffix
+    end
+    def refresh_infos
+      @length = @best_score = @worst_score = @best_suffix = @worst_suffix = nil
+      self
+    end
+  end
+end

data/lib/macroape/matrix_on_background.rb

@@ -0,0 +1,16 @@
+module PWM
+  class MatrixOnBackground < SingleMatrix
+    attr_reader :probabilities
+    def initialize(matrix,background)
+      super(matrix)
+      @probabilities = background
+    end
+    def sum_of_probabilities
+      @sum_of_probabilities ||= probabilities.inject(0.0, &:+)
+    end
+    def number_of_words
+      sum_of_probabilities ** length
+    end
+    include GaussEstimation, ThresholdByPvalue, CountByThreshold
+  end
+end

data/lib/macroape/matrix_transformations.rb

@@ -0,0 +1,29 @@
+module PWM
+  module MatrixTransformations
+    def reverse_complement
+      clone_and_transform( matrix.reverse.map(&:reverse) ).refresh_infos
+    end
+    def left_augment(n)
+      clone_and_transform( [[0.0]*4]* n + matrix ).refresh_infos
+    end
+    def right_augment(n)
+      clone_and_transform( matrix + [[0.0]*4]* n ).refresh_infos
+    end
+    def shift_to_zero # make worst score == 0 by shifting scores of each column
+      clone_and_transform( matrix.map{|col| col.map{|letter| letter - col.min}} ).refresh_infos
+    end
+    def discrete(rate)
+      clone_and_transform( matrix.map{|col| col.map{|letter| (letter * rate).ceil}} ).refresh_infos
+    end
+    def split(length_of_first_part)
+      [clone_and_transform( matrix.first(length_of_first_part)).refresh_infos, clone_and_transform(matrix.last(length - length_of_first_part)).refresh_infos]
+    end
+    def permute_columns(permutation_index)
+      clone_and_transform( permutation_index.map{|col| matrix[col]} ).refresh_infos
+    end
+    
+    def clone_and_transform(new_matrix)
+      self.dup.instance_eval{ @matrix = new_matrix; self }
+    end
+  end
+end

data/lib/macroape/pair_metrics.rb

@@ -0,0 +1,9 @@
+module PWMCompare
+  module PairMetrics
+    def jaccard(threshold_first, threshold_second)
+      self.map_each_align do |align, alignment_info|
+        align.jaccard(threshold_first, threshold_second).merge(alignment_info)
+      end.max_by {|alignment_info| alignment_info[:similarity]}
+    end
+  end
+end

data/lib/macroape/pair_transformations.rb

@@ -0,0 +1,28 @@
+module PWMCompare
+  module PairTransformations
+    
+    def each
+      second_rc = second.reverse_complement
+      (-second.length..first.length).to_a.product([:direct,:revcomp]) do |shift, orientation|
+        first_pwm_alignment = '.' * [-shift, 0].max + '>' * first.length
+        second_pwm_alignment = '.' * [shift, 0].max + (orientation == :direct ? '>' : '<') * second.length
+        overlap = [first.length + [-shift,0].max, 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] = '.'}
+        
+        yield(PWMCompareAligned.new(first.left_augment([-shift,0].max), 
+                                    (orientation == :direct ? second : second_rc).left_augment([shift,0].max)),
+              text: "#{first_pwm_alignment}\n#{second_pwm_alignment}",
+              shift: shift,
+              orientation: orientation,
+              overlap: overlap,
+              alignment_length: alignment_length
+              )
+      end
+    end
+    include Enumerable
+    alias :each_align :each
+    alias :map_each_align :map
+  end
+end

data/lib/macroape/pwm_compare.rb

@@ -0,0 +1,10 @@
+module PWMCompare
+  class PWMCompare
+    attr_reader :first, :second
+    def initialize(first, second)
+      @first = first
+      @second = second
+    end
+    include PairTransformations, PairMetrics
+  end
+end

data/lib/macroape/pwm_compare_aligned.rb

@@ -0,0 +1,13 @@
+module PWMCompare
+  class PWMCompareAligned
+    attr_reader :first, :second, :length
+    def initialize(first, second)
+      @length = [first.length, second.length].max
+      @first = first.right_augment(@length - first.length)
+      @second = second.right_augment(@length - second.length)
+    end
+    
+    include AlignedPairTransformations, AlignedPairMetrics, AlignedPairIntersection
+    
+  end
+end

data/lib/macroape/single_matrix.rb

@@ -0,0 +1,45 @@
+module PWM
+  class SingleMatrix
+    attr_reader :matrix
+    attr_accessor :name
+    def initialize(matrix)
+      @matrix = matrix
+    end
+    include MatrixTransformations, MatrixInformation
+    
+    def self.build_matrix(lines, name = nil)
+      pwm_name = name
+      begin
+        lines.first.split.each{|x| Float(x) }
+        start_line = 0
+      rescue
+        start_line = 1
+        pwm_name = lines.first.chomp.match(/(?:>\s)?(.*)$/)[1]
+      end
+      
+      if lines[start_line].split.length == 4
+        pwm = SingleMatrix.new(lines[start_line..-1].map{|str| str.split.map(&:to_f)})
+      else
+        pwm = SingleMatrix.new(lines[start_line..-1].map{|str| str.split.map(&:to_f)}.transpose)
+      end
+      raise "PWM::SingleMatrix.build_matrix can't create matrix using this input" unless pwm.matrix.all?{|l| l.length == 4}
+      pwm.name = pwm_name
+      pwm
+    end
+    
+    def self.load_from_stdin(input_stream, name = nil)
+      build_matrix(input_stream.readlines, name)
+    end
+    def self.load_from_line_array(lines, name = nil)
+      build_matrix(lines, name)
+    end
+    
+    def self.load_pat(filename)
+      build_matrix( File.open(filename,'r'){|f| f.readlines}, File.basename_wo_ext(filename))
+    end
+    
+    def with_background(background)
+      type_cast(MatrixOnBackground){@probabilities = background}.depth_dup
+    end
+  end
+end

data/lib/macroape/support.rb

@@ -0,0 +1,34 @@
+module Kernel
+  def type_cast(new_class, &block)
+    new_obj = new_class.allocate  
+    instance_variables.each do |varname|
+      new_obj.instance_variable_set(varname, self.instance_variable_get(varname))
+    end
+    new_obj.instance_eval(&block) if block_given?
+    new_obj
+  end
+  
+  def depth_dup
+    begin
+      new_obj = self.dup
+    rescue
+      return self
+    end
+    new_obj.instance_variables.each do |varname|
+      begin
+        new_obj.instance_variable_set(varname, new_obj.instance_variable_get(varname).depth_dup)
+      rescue
+      end
+    end
+    new_obj
+  end
+  
+end
+
+def File.filename_wo_ext(filename)
+  filename[0..-(1+File.extname(filename).length)]
+end
+
+def File.basename_wo_ext(filename)
+  File.basename(filename)[0..-(1+File.extname(filename).length)]
+end