vienna_rna 0.8.6 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 99cbd2a9afe1fb15daae72432caf558589d780f9
-  data.tar.gz: fbb4a27a788983898147fbb67bcbf91cae0cbaed
+  metadata.gz: 1fc492c40bf3f4d1c52ecf1afd09810c9798471a
+  data.tar.gz: 2a7ea6a2eeaca132e055e6aacc3cb1f0456990ef
 SHA512:
-  metadata.gz: 17f72d39b411f7ad5b19aaa60d11e91e392a86eae84712f95c804ce121648f55b85adbb904bf536ec137b590707f70d6b66b4a85cdf501501e0e68b8286f224f
-  data.tar.gz: 550bb20dbbc67f04cec01471db211378aa50e5784296c603f1871e2ab60d3bda6f02e2924d97cba4cbd39ab5d4b268392aa2634a55b1758e089187b3252e7ce1
+  metadata.gz: 16e9902e83a11b8143b598b565ce2d9acf78e0dcd59a89079cecace6d40e9eff4108fa331e1488ed29ce6b281d2d76a132e6fa84d377ec4a0c14004f19be1d2f
+  data.tar.gz: 191f17dea3941c52c2c990d29e881bd331bc96cdee50857f42f7acfa5b27a252c61966600e7e13e88a6f6fbbf75571afd5c31f0cd98cc75773060f96eb2f86fc

data/lib/vienna_rna/global/parser.rb

@@ -0,0 +1,19 @@
+module ViennaRna
+  module Global
+    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
+end

data/lib/vienna_rna/global/rna.rb

@@ -0,0 +1,115 @@
+module ViennaRna
+  module Global
+    class Rna
+      include 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
+end

data/lib/vienna_rna/global/rna_extensions.rb

@@ -0,0 +1,109 @@
+module ViennaRna
+  module Global
+    module RnaExtensions
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+        base.extend(ClassMethods)
+        base.extend(OneStructureBasedMethods)
+        base.extend(TwoStructureBasedMethods)
+             
+        base.class_eval do
+          OneStructureBasedMethods.public_instance_methods.each do |class_method|
+            define_method(class_method) do |*args|
+              self.class.send(class_method, *[structure].concat(args))
+            end
+          end
+        
+          TwoStructureBasedMethods.public_instance_methods.each do |class_method|
+            define_method(class_method) do |*args|
+              self.class.send(class_method, *[str_1, str_2].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 dishuffle
+          self.class.shuffle(sequence, 2)
+        end
+      
+        def gc_content
+          seq.split(//).select { |i| i =~ /[GC]/i }.size.to_f / seq.size
+        end
+      end
+    
+      module OneStructureBasedMethods
+        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 TwoStructureBasedMethods
+        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
+      end
+    end
+  end
+end

data/lib/vienna_rna/{modules/graphing.rb → graphing/r.rb}

@@ -9,31 +9,70 @@ module ViennaRna
             raise unless e.message == "Unsupported data type on R's end"
           end
         end
-
-        def line_graph(data, title: nil, type: "l", x_label: "Independent", y_label: "Dependent", filename: false)
+        
+        def overlay(data, title: nil, type: ?l, x_label: "Independent", y_label: "Dependent", legend: "topleft", filename: false)
+          # data: [{ data: [[x_0, y_0], ..., [x_n, y_n]], legend: "Line 1" }, ...]
+          
+          x_points = data.map { |hash| hash[:data].map(&:first) }
+          y_points = data.map { |hash| hash[:data].map(&:last) }
+          x_range  = Range.new(x_points.map(&:min).min.floor, x_points.map(&:max).max.ceil)
+          y_range  = Range.new(y_points.map(&:min).min.floor, y_points.map(&:max).max.ceil)
+          
           graph do |r|
-            r.assign("line_graph.x", data.map(&:first))
-            r.assign("line_graph.y", data.map(&:last))
-            
             r.eval("%s('%s', 6, 6)" % [
               writing_file?(filename) ? "pdf" : "quartz", 
               writing_file?(filename) ? filename : "Graph", 
             ])
             
+            r.assign("legend.titles", data.each_with_index.map { |hash, index| hash[:legend] || "Line #{index + 1}" })
+            r.eval("line.colors <- rainbow(%d)" % data.size)
+            r.eval("plot(0, 0, type = 'n', cex = .75, xlab = '', ylab = '', xlim = c(%d, %d), ylim = c(%d, %d))" % [
+              x_range.min, x_range.max, y_range.min, y_range.max
+            ])
+            
+            data.each_with_index do |hash, index|
+              r.assign("line_graph.x.%d" % index, x_points[index])
+              r.assign("line_graph.y.%d" % index, y_points[index])
+              
+              r.eval <<-STR
+                lines(
+                  line_graph.x.#{index}, 
+                  line_graph.y.#{index}, 
+                  col  = line.colors[#{index + 1}],
+                  type = "#{type}",
+                  pch  = #{index}
+                )
+              STR
+            end
+            
             r.eval <<-STR
-              plot(
-                line_graph.x, 
-                line_graph.y, 
+              title(
                 xlab = "#{x_label}", 
                 ylab = "#{y_label}", 
-                main = "#{title || 'Line Graph'}", 
-                type = "#{type}"
+                main = "#{title || 'Line Graph'}"
               )
             STR
+              
+            if legend
+              r.eval <<-STR
+                legend(
+                  "#{legend}",
+                  legend.titles,
+                  bty = "n",
+                  col = line.colors,
+                  lty = rep(1, #{data.size}),
+                  pch = 0:#{data.size}
+                )
+              STR
+            end
             
             r.eval("dev.off()") if writing_file?(filename)
           end
         end
+
+        def line_graph(data, title: nil, type: ?l, x_label: "Independent", y_label: "Dependent", filename: false)
+          overlay([{ data: data }], title: title, type: type, x_label: x_label, y_label: y_label, legend: false, filename: filename)
+        end
         
         def histogram(data, title: nil, x_label: "Bins", bin_size: 1, relative: false, filename: false)
           half     = bin_size / 2.0
@@ -150,106 +189,5 @@ module ViennaRna
         end
       end
     end
-
-    module Gnuplot
-      class << self
-        def plot(data, options = {})
-          Gnuplot.open do |gnuplot|
-            Gnuplot::Plot.new(gnuplot) do |plot|
-              plot.autoscale
-              
-              case options[:output]
-              when /file/i then
-                plot.output(options[:filename])
-                plot.terminal("png size %s" % (options[:dimensions] || "800,600"))
-              end
-              
-              (options[:plot] || {}).keys.each do |option|
-                plot.send(option, options[:plot][option])
-              end
-
-              plot.data = data.map do |data_hash|
-                Gnuplot::DataSet.new([data_hash[:x], data_hash[:y]]) do |dataset|
-                  dataset.with      = data_hash[:style] || "points"
-                  dataset.linecolor = "rgb '#{data_hash[:color]}'" if data_hash[:color]
-
-                  data_hash[:title] ? dataset.title = data_hash[:title] : dataset.notitle
-                end
-              end
-            end
-          end
-        end
-        
-        def splot(data, options = {})
-          # [[x_1, y_1, z_1], [x_2, y_2, z_2], ...]
-          orthogonal_data = data.inject([[], [], []]) { |array, list| array.zip(list).map { |a, e| a << e } }
-          
-          Gnuplot.open do |gnuplot|
-            Gnuplot::SPlot.new(gnuplot) do |plot|
-              plot.autoscale
-              
-              case options[:output]
-              when /file/i then
-                plot.output(options[:filename])
-                plot.terminal("png size 800,600")
-              end
-              
-              (options[:plot] || {}).keys.each do |option|
-                plot.send(option, options[:plot][option])
-              end
-
-              plot.data = [
-                Gnuplot::DataSet.new(orthogonal_data) do |dataset|
-                  dataset.with = options[:style] || "lines"
-                end
-              ]
-            end
-          end
-        end
-        
-        def histogram(data, title = "", options = {})
-          bin_size = options.delete(:bin_size) || 1
-          half     = bin_size / 2.0
-          range    = Range.new((data.min - half).floor, (data.max + half).ceil)
-          groups   = (range.min + half).step(range.max, bin_size).map { |x| [x, data.count { |i| i >= x - half && i < x + half }] }
-          
-          options.merge!(output: "file") if options[:filename]
-          options[:plot] = (options[:plot] || {}).merge({
-            title:  title,
-            yrange: "[0:#{groups.map(&:last).max * 1.1}]",
-            xtics:  "#{[bin_size, 5].max}",
-            style:  "fill solid 0.5 border"
-          })
-    
-          plot([{ x: groups.map(&:first), y: groups.map(&:last), style: "boxes" }], options)
-        end
-        
-        def roc(data, title = "", options = {})
-          # data = [[true_score_1, true_score_2, ...], [false_score_1, false_score_2, ...]]~
-          roc_curve = ROC.curve_points({ 1 => data[0], -1 => data[1] }.inject([]) { |data, (truth, values)| data.concat(values.map { |i| [i, truth] })})
-          area      = roc_curve.each_cons(2).inject(0) do |sum, (a, b)| 
-            delta_x, delta_y = b[0] - a[0], b[1] - a[1]
-            sum + (delta_x * delta_y / 2 + delta_x * [a[1], b[1]].min)
-          end
-          
-          options.merge!(output: "file") if options[:filename]
-          options.merge!({ plot: { title: "%s %s %.4f" % [title, "AUC:", area] } })
-    
-          plot([{ x: roc_curve.map(&:first), y: roc_curve.map(&:last), style: "lines" }], options)
-        end
-        
-        def quick_plot(data, title = "", options = {})
-          quick_overlay([{ data: data }], title, options)
-        end
-        
-        def quick_overlay(data, title = "", options = {})
-          # [{ data: [[x_0, y_0], [x_1, y_1], ...], label: "Label" }, { data: [[x_0, y_0], [x_1, y_1], ...] }]
-          options[:plot] = ((options[:plot] || {}).merge(title: title))
-          options.merge!(output: "file") if options[:filename]
-          
-          plot(data.map { |hash| { title: hash[:label], x: hash[:data].map(&:first), y: hash[:data].map(&:last), style: "linespoints" }.merge(hash[:options] || {}) }, options)
-        end
-      end
-    end
   end
 end

data/lib/vienna_rna/package/base.rb

@@ -0,0 +1,117 @@
+module ViennaRna
+  module Package
+    class Base
+      class_attribute :executable_name
+    
+      class << self
+        def method_added(name)
+          if name == :run
+            unless @chaining
+              @chaining = true
+              alias_method_chain :run, :hooks
+            else
+              remove_instance_variable(:@chaining)
+            end
+          end
+        end
+      
+        def exec_exists?(name)
+          !%x[which RNA#{name.to_s.downcase}].empty?
+        end
+      
+        def run(*data)
+          flags = data.length > 1 && data.last.is_a?(Hash) ? data.pop : {}
+          new(data).run(flags)
+        end
+      
+        def bootstrap(data: nil, output: "")
+          new(data).tap do |object|
+            object.instance_variable_set(:@response, File.exist?(output) ? File.read(output).chomp : output)
+          end
+        end
+      end
+    
+      attr_reader :data, :response, :runtime
+    
+      def exec_name
+        if executable_name
+          executable_name.respond_to?(:call) ? self.class.module_exec(&executable_name) : executable_name
+        else
+          "RNA#{self.class.name.split('::').last.underscore}"
+        end
+      end
+    
+      def exec_sequence_format
+        if data.str
+          '"%s
+          %s"' % [data.seq, data.str]
+        else
+          data.seq
+        end
+      end
+    
+      def initialize(data)
+        data  = [data] unless data.is_a?(Array)
+      
+        @data = case data.map(&:class)
+        when [ViennaRna::Global::Rna]         then data.first
+        when *(1..3).map { |i| [String] * i } then RNA.from_string(*data)
+        when [Hash]                           then RNA.from_hash(*data)
+        when [Array]                          then RNA.from_array(*data)
+        when [NilClass]                       then ViennaRna::Global::Rna.placeholder
+        else raise TypeError.new("Unsupported ViennaRna::Global::Rna#initialize format: #{data}")
+        end
+      end
+    
+      def run_with_hooks(flags = {})
+        unless @response
+          tap do
+            @runtime = Benchmark.measure do
+              pre_run_check unless respond_to?(:run_command)
+              @response = run_without_hooks(flags)
+              post_process if respond_to?(:post_process)
+            end
+        
+            ViennaRna.debugger { "Total runtime: %.3f sec." % runtime.real }
+          end
+        else
+          self
+        end
+      end
+    
+      def pre_run_check
+        if %x[which #{exec_name}].empty?
+          raise RuntimeError.new("#{exec_name} is not defined on this machine")
+        end
+      end
+    
+      def stringify_flags(flags)
+        base_flags = self.class.const_defined?(:BASE_FLAGS) ? self.class.const_get(:BASE_FLAGS) : {}
+      
+        flags.merge(base_flags).inject("") do |string, (flag, value)| 
+          (string + (value == :empty ? " -%s" % flag : " -%s %s" % [flag, value])).strip
+        end
+      end
+    
+      def run(flags = {})
+        command = if respond_to?(:run_command)
+          method(:run_command).arity.zero? ? run_command : run_command(flags)
+        else
+          "echo #{exec_sequence_format} | #{exec_name} #{stringify_flags(flags)}"
+        end
+      
+        ViennaRna.debugger { command }
+        
+        %x[#{command}]
+      end
+    
+      def serialize
+        YAML.dump(self)
+      end
+    
+      def debugger(&block)
+        self.class.debugger(&block)
+      end
+    end
+  end
+end

data/lib/vienna_rna/package/energy_grid_2d.rb

@@ -0,0 +1,69 @@
+module ViennaRna
+  module Package
+    class EnergyGrid2d < Base
+      include Enumerable
+    
+      def self.inherited(subclass)
+        subclass.class_eval { prepend EnergyGrid2dWrapper }
+      end
+    
+      module EnergyGrid2dWrapper
+        def distribution
+          super.map { |row| Row2d.new(*row) }.select { |row| row.p > 0 }.sort
+        end
+      end
+    
+      class Row2d
+        attr_reader :i, :j, :p, :ensemble
+  
+        def initialize(i, j, p, ensemble)
+          @i, @j, @p, @ensemble = i.to_i, j.to_i, BigDecimal.new(p.to_s), BigDecimal.new(ensemble.to_s)
+        end
+      
+        def position
+          [i, j]
+        end
+    
+        def <=>(other_row)
+          i == other_row.i ? j <=> other_row.j : i <=> other_row.i
+        end
+      
+        def inspect
+          "#<Row2d (%d, %d), p: %s, ensemble: %s>" % [i, j, p, ensemble]
+        end
+      end
+    
+      def self.aligned_distributions(*energy_grids)
+        point_set = set_of_points(*energy_grids)
+      
+        energy_grids.map do |grid|
+          (grid.distribution + (point_set - grid.map(&:position)).map { |i, j| Row2d.new(i, j, 0, Float::INFINITY) }).sort
+        end
+      end
+    
+      def self.set_of_points(*energy_grids)
+        energy_grids.inject([]) { |list, grid| list + grid.map(&:position) }.uniq.sort
+      end
+    
+      def each(&block)
+        distribution.each(&block)
+      end
+    
+      def quick_plot(num_colors: 8)
+        Graphing::R.matrix_heatmap(
+          distribution.map(&:i), 
+          distribution.map(&:j), 
+          distribution.map { |row| Math.log(row.p) },
+          title:      "#{self.class.name} Matrix Heatmap",
+          x_label:    "Distance from structure 2",
+          y_label:    "Distance from structure 1",
+          num_colors: num_colors
+        )
+      end
+    
+      def inspect
+        "#<#{self.class.name} on #{data.inspect}>"
+      end
+    end
+  end
+end

data/lib/vienna_rna/package/eval.rb

@@ -0,0 +1,11 @@
+module ViennaRna
+  module Package
+    class Eval < Base
+      attr_reader :mfe
+    
+      def post_process
+        @mfe = ViennaRna::Global::Parser.rnafold_mfe(@response)
+      end
+    end
+  end
+end

data/lib/vienna_rna/package/fftbor.rb

@@ -0,0 +1,19 @@
+module ViennaRna
+  module Package
+    class Fftbor < Xbor
+      def partition
+        response.split(/\n/).find { |line| line =~ /^Scaling factor.*:\s+(\d+\.\d+)/ }
+        BigDecimal.new($1)
+      end
+    
+      def total_count
+        response.split(/\n/).find { |line| line =~ /^Number of structures: (\d+)/ }
+        $1.to_i
+      end
+    
+      def distribution
+        self.class.parse(response).map { |row| BigDecimal.new(row[1]) }
+      end
+    end
+  end
+end

data/lib/vienna_rna/package/fftbor2d.rb

@@ -0,0 +1,25 @@
+module ViennaRna
+  module Package
+    class Fftbor2d < EnergyGrid2d
+      BASE_FLAGS = {
+        S: :empty
+      }
+
+      self.executable_name = "FFTbor2D"
+
+      def run_command(flags = {})
+        ViennaRna.debugger { "Running #{exec_name} 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)), 
+          data.temp_fa_file!
+        ]
+      end
+    
+      def distribution
+        response.split(/\n/).map { |line| line.split(/\t/) }
+      end
+    end
+  end
+end