wrnap 0.0.1

data/lib/wrnap/graphing/r.rb

@@ -0,0 +1,229 @@
+module Wrnap
+  module Graphing
+    module R
+      class << self
+        def graph(&block)
+          begin
+            (yield (r_instance = RinRuby.new)).tap { r_instance.close }
+          rescue RuntimeError => e
+            raise unless e.message == "Unsupported data type on R's end"
+          end
+        end
+        
+        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.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, cex.axis = .9, 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
+              title(
+                xlab     = #{expressionify(x_label)}, 
+                ylab     = #{expressionify(y_label)}, 
+                main     = #{expressionify(title || "Line Graph")},
+                cex.main = .9,
+                cex.lab  = .9
+              )
+            STR
+              
+            if legend
+              r.eval <<-STR
+                legend(
+                  "#{legend}",
+                  legend.titles,
+                  bty = "o",
+                  bg  = rgb(1, 1, 1, .5, 1),
+                  col = line.colors,
+                  lty = rep(1, #{data.size}),
+                  pch = 0:#{data.size},
+                  cex = .6
+                )
+              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 scatterplot(data, title: nil, x_label: "Independent", y_label: "Dependent", filename: false)
+          line_graph(data, title: title || "Scatterplot", type: ?p, x_label: x_label, y_label: y_label, filename: filename)
+        end
+        
+        def roc(data, title: nil, baseline: true, filename: false)
+          # data: [[-0.894, 1.0], [-0.950, 1.0], [0.516, -1.0], ..., [0.815, -1.0], [0.740, -1.0]]
+          auc            = ROC.auc(data)
+          title_with_auc = title ? "%s (AUC: %.4f)" % [title, auc] : "AUC: %.4f" % auc
+          overlay(
+            [{ data: ROC.curve_points(data) }, { data: [[0, 0], [1, 1]] }], 
+            title:    title_with_auc, 
+            x_label:  "False positive rate", 
+            y_label:  "True positive rate", 
+            legend:   false, 
+            filename: filename
+          )
+        end
+        
+        def roc_overlay(data, title: nil, auc_in_legend: true, filename: false)
+          # [{ data: [[-0.894, 1.0], [-0.950, 1.0], [0.516, -1.0], ..., [0.815, -1.0], [0.740, -1.0]], legend: "ROC 1" }, ...]
+          formatted_data = data.map do |hash|
+            curve_points = ROC.curve_points(hash[:data])
+            
+            if auc_in_legend
+              auc    = ROC.auc(hash[:data])
+              legend = hash[:legend] ? "%s (AUC: %.4f)" % [hash[:legend], auc] : "AUC: %.4f" % auc
+              
+              hash.merge({ data: curve_points, legend: legend })
+            else
+              hash.merge({ data: curve_points })
+            end
+          end
+          
+          
+          overlay(
+            formatted_data, 
+            title:    title, 
+            x_label:  "False positive rate", 
+            y_label:  "True positive rate", 
+            legend:   "bottomright", 
+            filename: filename
+          )
+        end
+        
+        def histogram(data, title: nil, x_label: "Bins", num_bins: false, bin_size: 1, x_arrow: false, relative: false, filename: false)
+          half     = bin_size / 2.0
+          range    = Range.new((data.min - half).floor, (data.max + half).ceil)
+          breaks   = num_bins ? num_bins : (range.min + half).step(range.max + half, bin_size).to_a
+          
+          graph do |r|
+            r.assign("histogram.data", data)
+            r.assign("histogram.breaks", breaks)
+            
+            r.eval("%s('%s', 6, 6)" % [
+              writing_file?(filename) ? "pdf" : "quartz", 
+              writing_file?(filename) ? filename : "Histogram", 
+            ])
+            
+            r.eval <<-STR
+              hist(
+                histogram.data, 
+                breaks   = histogram.breaks, 
+                xlab     = #{expressionify(x_label)}, 
+                main     = #{expressionify(title || "Histogram")}, 
+                freq     = #{relative ? 'F' : 'T'},
+                cex.main = 0.9,
+                cex.lab  = 0.9,
+                cex.axis = 0.9
+              )
+            STR
+            
+            r.eval("abline(v = #{x_arrow}, lty = 'dashed')") if x_arrow
+            
+            r.eval("dev.off()") if writing_file?(filename)
+          end
+        end
+        
+        def matrix_heatmap(x, y, z, title: nil, x_label: "Column index", y_label: "Row index", filename: false, num_colors: 64)
+          graph do |r|
+            if r.pull("ifelse('Matrix' %in% rownames(installed.packages()), 1, -1)") > 0
+              if forced_square = (x.max != y.max)
+                x << [x, y].map(&:max).max
+                y << [x, y].map(&:max).max
+                z << 0
+              end
+              
+              r.assign("matrix.i", x)
+              r.assign("matrix.j", y)
+              r.assign("matrix.x", z)
+              r.eval <<-STR
+                require("Matrix")
+                matrix.data <- sparseMatrix(
+                i      = matrix.i,
+                j      = matrix.j,
+                x      = matrix.x,
+                index1 = F
+                )
+              STR
+              
+              generate_graph("Heatmap") do
+                <<-STR
+                  filtered.values <- Filter(function(i) { is.finite(i) & i != 0 }, matrix.x)
+                  print(apply(as.matrix(matrix.data), 2, rev))
+                  print(c(sort(filtered.values)[2], max(filtered.values)))
+                
+                  image(
+                    x    = 1:max(c(dim(matrix.data)[[1]], dim(matrix.data)[[2]])), 
+                    y    = 1:max(c(dim(matrix.data)[[1]], dim(matrix.data)[[2]])), 
+                    z    = as.matrix(matrix.data),
+                    col  = rev(heat.colors(#{num_colors})),
+                    zlim = #{forced_square ? "c(sort(filtered.values)[2], max(filtered.values))" : "c(min(filtered.values), max(filtered.values))"},
+                    xlab = "#{x_label} (1-indexed)",
+                    ylab = "#{y_label} (1-indexed)"
+                  )
+                  title(#{expressionify(title || "Matrix Heatmap")})
+                STR
+              end
+            else
+              puts "Please install the Matrix package for R before using this function."
+            end
+          end
+        end
+        
+        private
+        
+        def generate_graph(window_title = "ViennaRNA Graph in R", &block)
+          r, filename = block.binding.eval("[r, filename]")
+          
+          r.eval("%s('%s', 6, 6)" % [
+            writing_file?(filename) ? "pdf" : "quartz", 
+            writing_file?(filename) ? filename : window_title, 
+          ])
+          
+          r.eval(yield)
+          
+          r.eval("dev.off()") if writing_file?(filename)
+        end
+        
+        def writing_file?(filename)
+          filename && (filename = filename.end_with?(".pdf") ? filename : filename + ".pdf")
+        end
+        
+        def expressionify(string)
+          %w|expression paste|.any?(&string.method(:start_with?)) ? string : string.inspect
+        end
+      end
+    end
+  end
+end

data/lib/wrnap/package/base.rb

@@ -0,0 +1,73 @@
+module Wrnap
+  module Package
+    def self.lookup(package_name)
+      const_missing("#{package_name}".camelize) || raise(ArgumentError.new("#{package_name} can't be resolved as an executable"))
+    end
+
+    class Base
+      include Wrnap::Global::RunExtensions
+      include Wrnap::Global::ChainExtensions
+
+      class_attribute :executable_name
+      self.executable_name = ->(context) { "RNA#{context.class.name.split('::').last.underscore}" }
+
+      class_attribute :call_with
+      self.call_with = [:seq]
+
+      class_attribute :default_flags
+      self.default_flags = {}
+
+      class_attribute :quote_flag_params
+      self.quote_flag_params = []
+
+      class_attribute :chains_from
+      self.chains_from = Object
+
+      class << self
+        def bootstrap(data: nil, output: "")
+          new(data).tap do |object|
+            object.instance_variable_set(:@response, File.exist?(output) ? File.read(output).chomp : output)
+            object.post_process if object.respond_to?(:post_process)
+          end
+        end
+      end
+
+      attr_reader :data, :flags, :response, :runtime
+
+      def initialize(data, chaining: false)
+        unless chaining
+          data  = [data] unless data.is_a?(Array)
+
+          @data = case data.map(&:class)
+          when [Wrnap::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 Wrnap::Global::Rna.placeholder
+          else raise TypeError.new("Unsupported Wrnap::Global::Rna#initialize format: #{data}")
+          end
+        else
+          @data = transform_for_chaining(data)
+        end
+      end
+
+      def serialize
+        YAML.dump(self)
+      end
+
+      def debugger(&block)
+        self.class.debugger(&block)
+      end
+
+      def inspect
+        "#<%s (%.2f sec): data: %s, flags: %s, vars: %s>" % [
+          self.class.name,
+          runtime.real,
+          data,
+          flags,
+          (instance_variables - %i|@data @flags @response @runtime|).map(&:to_s).sort.join(", ")
+        ]
+      end
+    end
+  end
+end

data/lib/wrnap/package/energy_grid_2d.rb

@@ -0,0 +1,81 @@
+module Wrnap
+  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 to_csv(energy_term: :p)
+          "%d,%d,%.8f" % [i, j, instance_variable_get(:"@#{energy_term}")]
+        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 to_csv(energy_term: :p)
+        map { |row| row.to_csv(energy_term: energy_term) }.join(?\n) + ?\n
+      end
+      
+      def to_csv!(filename, energy_term: :p)
+        File.open(filename, ?w) { |file| file.write(to_csv(energy_term: energy_term)) }
+      end
+    
+      def inspect
+        "#<#{self.class.name} on #{data.inspect}>"
+      end
+    end
+  end
+end

data/lib/wrnap/package/eval.rb

@@ -0,0 +1,13 @@
+module Wrnap
+  module Package
+    class Eval < Base
+      self.call_with = [:seq, :str]
+      
+      attr_reader :mfe
+    
+      def post_process
+        @mfe = Wrnap::Global::Parser.rnafold_mfe(response)
+      end
+    end
+  end
+end

data/lib/wrnap/package/fft_mfpt.rb

@@ -0,0 +1,24 @@
+# Maybe add something like flagsets so that common option groups can be combined together.
+# Also, add a rerun feature.
+
+module Wrnap
+  module Package
+    class FftMfpt < Base
+      self.executable_name = "FFTmfpt"
+      
+      attr_reader :mfpt
+    
+      def run_command(flags)      
+        "%s %s %s" % [
+          exec_name, 
+          stringify_flags(flags), 
+          data.temp_fa_file!
+        ]
+      end
+    
+      def post_process
+        @mfpt = response.to_f
+      end
+    end
+  end
+end

data/lib/wrnap/package/fftbor.rb

@@ -0,0 +1,19 @@
+module Wrnap
+  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/wrnap/package/fftbor2d.rb

@@ -0,0 +1,22 @@
+module Wrnap
+  module Package
+    class Fftbor2d < EnergyGrid2d
+      self.executable_name = "FFTbor2D"
+      self.default_flags   = ->(_, flags) { (flags.keys & %i|M S|).empty? ? { S: :empty } : {} }
+
+      def run_command(flags)
+        Wrnap.debugger { "Running #{exec_name} on #{data.inspect}" }
+
+        "%s %s %s" % [
+          exec_name,
+          stringify_flags(flags),
+          data.temp_fa_file!
+        ]
+      end
+
+      def distribution
+        response.split(/\n/).map { |line| line.split(/\t/) }
+      end
+    end
+  end
+end

data/lib/wrnap/package/ffthairpin.rb

@@ -0,0 +1,7 @@
+module Wrnap
+  module Package
+    class Ffthairpin < Fftbor
+      self.executable_name = "FFThairpin"
+    end
+  end
+end

data/lib/wrnap/package/fftmultiloop.rb

@@ -0,0 +1,7 @@
+module Wrnap
+  module Package
+    class Fftmultiloop < Fftbor
+      self.executable_name = "FFTmultiloop"
+    end
+  end
+end

data/lib/wrnap/package/fold.rb

@@ -0,0 +1,25 @@
+module Wrnap
+  module Package
+    class Fold < Base
+      self.default_flags = {
+        "-noPS" => :empty
+      }
+    
+      attr_reader :mfe_rna, :structure, :mfe, :ensemble_energy
+    
+      def post_process
+        structure = Wrnap::Global::Parser.rnafold_mfe_structure(response)
+      
+        unless data.seq.length == structure.length
+          raise "Sequence: '#{data.seq}'\nStructure: '#{structure}'"
+        else
+          @mfe_rna, @structure, @mfe = RNA.from_string(data.seq, structure), structure, Wrnap::Global::Parser.rnafold_mfe(response)
+        end
+        
+        if flags[:p] == 0
+          @ensemble_energy = Wrnap::Global::Parser.rnafold_ensemble_energy(response)
+        end
+      end
+    end
+  end
+end

data/lib/wrnap/package/heat.rb

@@ -0,0 +1,15 @@
+module Wrnap
+  module Package
+    class Heat < Base
+      attr_reader :specific_heats
+    
+      def post_process
+        @specific_heats = response.split(/\n/).map { |line| line.split(/\s+/).map(&:to_f) }.inject({}) do |hash, (temp, specific_heat)|
+          hash.tap do
+            hash[temp] = specific_heat
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wrnap/package/kinwalker.rb

@@ -0,0 +1,24 @@
+module Wrnap
+  module Package
+    class Kinwalker < Base
+      self.executable_name = "kinwalker"
+      attr_reader :nodes
+                
+      def post_process
+        @nodes = response.split("TRAJECTORY").last.split(?\n).reject(&:empty?)[0..-2].map { |line| Node.new(*line.split(/\s+/)) }
+      end
+      
+      def mfpt
+        nodes.last.time
+      end
+      
+      class Node
+        attr_reader :structure, :energy, :time, :barrier, :energy_barrier, :transcribed
+        
+        def initialize(structure, energy, time, barrier, energy_barrier, transcribed)
+          @structure, @energy, @time, @barrier, @energy_barrier, @transcribed = structure, energy.to_f, time.to_f, barrier.to_f, energy_barrier.to_f, transcribed.to_i
+        end
+      end
+    end
+  end
+end

data/lib/wrnap/package/mfpt.rb

@@ -0,0 +1,40 @@
+# Maybe add something like flagsets so that common option groups can be combined together.
+# Also, add a rerun feature.
+
+module Wrnap
+  module Package
+    class Mfpt < Base
+      self.chains_from   = Wrnap::Package::EnergyGrid2d
+      self.default_flags = ->(context, flags) { { X: :empty, H: :empty, N: context.data.seq.length, D: context.data.bp_distance, Q: "1e-8" } }
+      # These flags aren't well setup for alternative options at the moment.
+      
+      attr_reader :mfpt
+      
+      def transform_for_chaining(previous_package)
+        previous_package.data.tap do |data|
+          data.instance_eval do
+            @previous_package = previous_package
+            
+            def energy_grid_csv
+              Tempfile.new("rna").path.tap do |energy_grid_csv|
+                @previous_package.to_csv!(energy_grid_csv)
+              end
+            end
+          end
+        end
+      end
+    
+      def run_command(flags)      
+        "%s %s %s" % [
+          exec_name, 
+          stringify_flags(flags), 
+          data.energy_grid_csv
+        ]
+      end
+    
+      def post_process
+        @mfpt = response.to_f
+      end
+    end
+  end
+end

data/lib/wrnap/package/plot.rb

@@ -0,0 +1,19 @@
+module Wrnap
+  module Package
+    class Plot < Base
+      self.call_with     = [ :comment, :seq, :str]
+      self.default_flags = {
+        t: 0,
+        o: "svg"
+      }
+
+      def run_command(flags)
+        "cat %s | %s %s" % [
+          data.temp_fa_file!,
+          exec_name,
+          stringify_flags(flags)
+        ]
+      end
+    end
+  end
+end