vienna_rna 0.8.6 → 0.9.0

data/lib/vienna_rna/modules/parser.rb

@@ -1,17 +0,0 @@
-module ViennaRna
-  module Parser
-    REGEXP = {
-      mfe: / \(\s*(-?\d*\.\d*)\)$/
-    }
-    
-    class << self
-      def rnafold_mfe_structure(response)
-        response.split(/\n/)[1].split(/\s+/).first
-      end
-      
-      def rnafold_mfe(response)
-        response.split(/\n/)[1].match(REGEXP[:mfe])[1].to_f
-      end
-    end
-  end
-end

data/lib/vienna_rna/modules/rna.rb

@@ -1,113 +0,0 @@
-module ViennaRna
-  class Rna
-    include ViennaRna::RnaExtensions
-    
-    attr_reader :sequence, :structure, :second_structure, :raw_data
-      
-    class << self
-      def init_from_string(sequence, structure = nil, second_structure = nil)
-        new(
-          sequence:         sequence, 
-          structure:        structure, 
-          second_structure: second_structure
-        )
-      end
-    
-      def init_from_hash(hash)
-        new(
-          sequence:         hash[:sequence]         || hash[:seq], 
-          structure:        hash[:structure]        || hash[:str_1] || hash[:str], 
-          second_structure: hash[:second_structure] || hash[:str_2], 
-          raw_data:         hash
-        )
-      end
-      
-      def init_from_array(array)
-        init_from_string(*array)
-      end
-      
-      def init_from_fasta(string)
-        string = File.read(string).chomp if File.exist?(string)
-        init_from_string(*string.split(/\n/).reject { |line| line.start_with?(">") }[0, 3])
-      end
-    
-      def init_from_self(rna)
-        # This happens when you call a ViennaRna library function with the output of something like ViennaRna::Fold.run(...).mfe
-        new(
-          sequence:         rna.sequence, 
-          strucutre:        rna.structure, 
-          second_strucutre: rna.second_structure, 
-          raw_data:         rna.raw_data
-        )
-      end
-      
-      alias_method :placeholder, :new
-    end
-    
-    def initialize(sequence: "", structure: "", second_structure: "", raw_data: {})
-      @sequence, @raw_data = sequence, raw_data
-      
-      [:structure, :second_structure].each do |structure_symbol|
-        instance_variable_set(
-          :"@#{structure_symbol}", 
-          case structure_value = eval("#{structure_symbol}")
-          when :empty then empty_structure
-          when :mfe   then RNA(sequence).run(:fold).mfe_rna.structure
-          when String then structure_value
-          end
-        )
-      end
-
-      if str && seq.length != str.length
-        ViennaRna.debugger { "The sequence length (%d) doesn't match the structure length (%d)" % [seq, str].map(&:length) }
-      end
-      
-      if str_2 && str_1.length != str_2.length
-        ViennaRna.debugger { "The first structure length (%d) doesn't match the second structure length (%d)" % [str_1, str_2].map(&:length) }
-      end
-    end
-    
-    alias :seq   :sequence
-    alias :str   :structure
-    alias :str_1 :structure
-    alias :str_2 :second_structure
-    
-    def empty_structure
-      "." * seq.length
-    end
-
-    alias :empty_str :empty_structure
-    
-    def write_fa!(filename, comment = nil)
-      filename.tap do |filename|
-        File.open(filename, ?w) do |file|
-          file.write("> %s\n" % comment) if comment
-          file.write("%s\n" % seq)       if seq
-          file.write("%s\n" % str_1)     if str_1
-          file.write("%s\n" % str_2)     if str_2
-        end
-      end
-    end
-    
-    def temp_fa_file!
-      write_fa!(Tempfile.new("")).path
-    end
-
-    def run(module_name, options = {})
-      if rna_module = ViennaRna.const_missing("#{module_name}".camelize)
-        rna_module.run(self, options)
-      else
-        raise ArgumentError.new("#{module_name} can't be resolved as an executable")
-      end
-    end
-
-    def inspect
-      "#<%s>" % [
-        "#{self.class.name}",
-        ("#{seq[0, 20]   + (seq.length > 20   ? '...' : '')}"          if seq && !seq.empty?),
-        ("#{str_1[0, 20] + (str_1.length > 20 ? ' [truncated]' : '')}" if str_1 && !str_1.empty?),
-        ("#{str_2[0, 20] + (str_2.length > 20 ? ' [truncated]' : '')}" if str_2 && !str_1.empty?),
-      ].compact.join(" ")
-    end
-  end
-end

data/lib/vienna_rna/modules/rna2dfold.rb

@@ -1,25 +0,0 @@
-module ViennaRna
-  class Rna2dfold < EnergyGrid2d
-    BASE_FLAGS = {
-      d:         0,
-      p:         :empty,
-      "-noBT" => :empty
-    }
-
-    self.executable_name = "RNA2Dfold"
-
-    def run_command(flags = {})
-      ViennaRna.debugger { "Running RNA2Dfold on #{data.inspect}" }
-      
-      "cat %s  | %s %s" % [
-        data.temp_fa_file!,
-        exec_name, 
-        stringify_flags(BASE_FLAGS.merge(self.class.const_defined?(:FLAGS) ? self.class.const_get(:FLAGS) : {}).merge(flags))
-      ]
-    end
-    
-    def distribution
-      response.split(/\n/)[6..-1].map { |line| line.split(/\t/).at_indexes([0, 1, 2, 6]) }
-    end
-  end
-end

data/lib/vienna_rna/modules/rna_extensions.rb

@@ -1,101 +0,0 @@
-module ViennaRna
-  module RnaExtensions
-    def self.included(base)
-      base.extend(ClassMethods)
-      base.send(:include, InstanceMethods)
-      base.extend(StructureBasedClassAndInstanceMethods)
-
-      # All the methods in here are also copied in as instance methods, where the first argument is the ViennaRna::Rna#structure      
-      base.class_eval do
-        StructureBasedClassAndInstanceMethods.public_instance_methods.each do |class_method|
-          define_method(class_method) do |*args|
-            self.class.send(class_method, *[structure].concat(args))
-          end
-        end
-      end
-      
-      base.send(:include, InstanceMethods)
-    end
-    
-    module ClassMethods
-      def generate_sequence(sequence_length)
-        # 0th order Markov chain w/ uniform probability distribution
-        Rna.init_from_string(sequence_length.times.inject("") { |string, _| string + %w[A U C G][rand(4)] })
-      end
-      
-      def shuffle(sequence, token_length = 2)
-        Shuffle.new(sequence).shuffle(token_length)
-      end
-    end
-
-    module InstanceMethods
-      def gc_content
-        seq.split(//).select { |i| i =~ /[GC]/i }.size.to_f / seq.size
-      end
-    end
-    
-    module StructureBasedClassAndInstanceMethods
-      def bp_distance(structure_1, structure_2)
-        # Takes two structures and calculates the distance between them by |symmetric difference(bp_in_a, bp_in_b)|
-        raise "The two structures are not the same length" unless structure_1.length == structure_2.length
-        
-        bp_set_1, bp_set_2 = base_pairs(structure_1), base_pairs(structure_2)
-        
-        ((bp_set_1 - bp_set_2) + (bp_set_2 - bp_set_1)).count
-      end
-      
-      def symmetric_bp_distance(structure_1, structure_2)
-        # Takes two structures and calculates the distance between them by: sum { ((x_j - x_i) - (y_j - y_i)).abs }
-        raise "The two structures are not the same length" unless structure_1.length == structure_2.length
-  
-        bp_dist = ->(array, i) { array[i] == -1 ? 0 : array[i] - i }
-  
-        structure_1_pairings = get_pairings(structure_1)
-        structure_2_pairings = get_pairings(structure_2)
-  
-        structure_1.length.times.inject(0) do |distance, i|
-          distance + (bp_dist[structure_1_pairings, i] - bp_dist[structure_2_pairings, i]).abs
-        end
-      end
-      
-      def max_bp_distance(structure)
-        base_pairs(structure).count + ((structure.length - 3) / 2.0).floor
-      end
-      
-      def base_pairs(structure)
-        get_pairings(structure).each_with_index.inject(Set.new) do |set, (j, i)|
-          j >= 0 ? set << Set[i, j] : set
-        end
-      end
-    
-      def get_pairings(structure)
-      	stack = []
-      
-        structure.each_char.each_with_index.inject(Array.new(structure.length, -1)) do |array, (symbol, index)|
-      	  array.tap do      
-      	    case symbol
-      	    when "(" then stack.push(index)
-      	    when ")" then 
-      	      if stack.empty?
-      	        raise "Too many ')' in '#{structure}'"
-      	      else
-      	        stack.pop.tap do |opening|
-      	          array[opening] = index
-      	          array[index]   = opening
-      	        end
-      	      end
-      	    end
-      	  end
-      	end.tap do
-      	  raise "Too many '(' in '#{structure}'" unless stack.empty?
-      	end
-      end
-    end
-    
-    module InstanceMethods
-      def dishuffle
-        self.class.shuffle(sequence, 2)
-      end
-    end
-  end
-end

data/lib/vienna_rna/modules/rnabor.rb

@@ -1,33 +0,0 @@
-require "tempfile"
-require "bigdecimal"
-
-module ViennaRna
-  class Rnabor < Xbor
-    FLAGS = {
-      nodangle: :empty
-    }
-    
-    def partition
-      non_zero_shells.inject(&:+)
-    end
-    
-    def total_count
-      counts.inject(&:+)
-    end
-    
-    def counts
-      (non_zero_counts = self.class.parse(response).map { |row| BigDecimal.new(row[2]).to_i }) + [0] * (data.seq.length - non_zero_counts.length + 1)
-    end
-    
-    def distribution(options = {})
-      options = { precision: 4 }.merge(options)
-      
-      distribution_before_precision = (non_zero_distribution = non_zero_shells.map { |i| i / partition }) + [0.0] * (data.seq.length - non_zero_distribution.length + 1)
-      distribution_before_precision.map { |value| options[:precision].zero? ? value : (value * 10 ** options[:precision]).truncate / 10.0 ** options[:precision] }
-    end
-    
-    def non_zero_shells
-      self.class.parse(response).map { |row| BigDecimal.new(row[1]) }
-    end
-  end
-end

data/lib/vienna_rna/modules/subopt.rb

@@ -1,17 +0,0 @@
-module ViennaRna
-  class Subopt < Base
-    attr_reader :structures
-    
-    def post_process
-      @structures = @response.split(/\n/)[1..-1].map { |output| Rna.init_from_string(data.seq, output.split(/\s+/).first) }
-    end
-    
-    def bin(count = 1)
-      run(p: count).structures.inject(Hash.new { |hash, key| hash[key] = 0 }) do |hash, structure|
-        hash.tap do
-          hash[structure] += 1
-        end
-      end
-    end
-  end
-end

data/lib/vienna_rna/modules/utils.rb

@@ -1,34 +0,0 @@
-module ViennaRna
-  module Utils
-    class << self
-      def fastas_from_file(path)
-        # Force it to not be lazy.
-        Bio::FlatFile.auto(path).to_enum.map { |fasta| fasta }
-      end
-      
-      def write_fastas!(fastas, directory, base_name, group_size = 10)
-        fastas.each_slice(group_size).each_with_index do |fasta_group, i|
-          path = File.join(directory, base_name + "_#{i}.fa")
-          
-          unless File.exists?(path)
-            File.open(path, "w") do |file|
-              fasta_group.each do |folding|
-                file.write(">%s\n%s\n" % [folding.fasta.definition, folding.fasta.seq])
-              end
-            end
-          else
-            puts "Warning: file '#{path}' exists. Skipping."
-          end
-        end
-      end
-
-      def regress(x, y, degree)
-        x_data   = x.map { |i| (0..degree).map { |power| i ** power.to_f } }
-        x_matrix = Matrix[*x_data]
-        y_matrix = Matrix.column_vector(y)
-
-        ((x_matrix.transpose * x_matrix).inverse * x_matrix.transpose * y_matrix).transpose.to_a[0]
-      end
-    end
-  end
-end

data/lib/vienna_rna/modules/xbor.rb

@@ -1,64 +0,0 @@
-require "tempfile"
-require "bigdecimal"
-
-module ViennaRna
-  class Xbor < Base
-    BASE_FLAGS = {
-      E: "/usr/local/bin/energy.par"
-    }
-    
-    self.executable_name = -> { name.demodulize.gsub(/^([A-Z].*)bor$/) { |match| $1.upcase + "bor" } }
-    
-    def run_command(flags = {})
-      file = Tempfile.new("rna")
-      file.write("%s\n" % data.seq)
-      file.write("%s\n" % data.str)
-      file.close
-      
-      ViennaRna.debugger { "Running FFTbor on #{data.inspect}" }
-      
-      "%s %s %s" % [
-        exec_name, 
-        stringify_flags(BASE_FLAGS.merge(self.class.const_defined?(:FLAGS) ? self.class.const_get(:FLAGS) : {}).merge(flags)), 
-        file.path
-      ]
-    end
-    
-    def self.bootstrap_from_file(path, klass = self)
-      log       = File.read(path)
-      sequence  = log.split(/\n/).first.split(/\s+/)[1]
-      structure = log.split(/\n/).first.split(/\s+/)[2]
-      
-      klass.bootstrap(Rna.init_from_string(sequence, structure), log)
-    end
-    
-    def self.parse(response)
-      response.split(/\n/).select { |line| line =~ /^\d+\t-?\d+/ }.map { |line| line.split(/\t/) }
-    end
-    
-    def full_distribution
-      distribution      = run.distribution
-      full_distribution = distribution + ([0.0] * ((differnece = data.seq.length - distribution.length + 1) < 0 ? 0 : differnece))
-    end
-    
-    def k_p_points
-      full_distribution.each_with_index.to_a.map(&:reverse)[0..data.seq.length]
-    end
-    
-    def expected_k
-      k_p_points.map { |array| array.inject(&:*) }.inject(&:+)
-    end
-    
-    def quick_plot(options = {})
-      ViennaRna::Graphing::Gnuplot.quick_plot(
-        k_p_points,
-        options[:title] || "%s\\n%s\\n%s" % [self.class.name, data.seq, data.safe_structure],
-        options
-      )
-    end
-    
-    def inspect
-      "#<#{self.class.name} #{data.inspect}>"
-    end
-  end
-end