vienna_rna 0.2.0 → 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 31ec4e6771f342a7ebc0093f628748a1d39ef940
+  data.tar.gz: f3e2f41a3957ca6a84cd38aaa390ae383a49f712
+SHA512:
+  metadata.gz: 949a4476d1acda83e807966ccc34b6bdfa57b93fdae096bd848b83970fca94383502fa36e2f06b45158c2347d64e5dfc138461f6d5cd83d35233b388cecb5321
+  data.tar.gz: 717e42a7999cffe4fa6994652c22edafcc66e01f35bb41b58305e2ab900572eb81c5e0d2aa4cea44fa5504a89b7f88e4ddc4e2c84833f3804d0423f9e2b5a300

data/lib/vienna_rna/modules/base.rb

@@ -20,7 +20,8 @@ module ViennaRna
         !%x[which rna#{name.to_s.downcase}].empty?
       end
       
-      def run(data, flags = {})
+      def run(*data)
+        flags = data.length > 1 && data.last.is_a?(Hash) ? data.pop : {}
         new(data).run(flags)
       end
       
@@ -65,11 +66,14 @@ module ViennaRna
     end
     
     def initialize(data)
-      @data = case data
-      when Bio::FastaFormat then data
-      when Rna              then data
-      when String           then Rna.new(data)
-      when Hash             then Rna.new(data[:sequence] || data[:seq], data[:structure] || data[:str])
+      data  = [data] unless data.is_a?(Array)
+      
+      @data = case data.map(&:class)
+      when [Rna]                      then data.first
+      when [String], [String, String] then Rna.init_from_string(*data)
+      when [Hash]                     then Rna.init_from_hash(*data)
+      when [Array]                    then Rna.init_from_array(*data)
+      else raise TypeError.new("Unsupported ViennaRna::Rna#initialize format: #{data}")
       end
     end
     

data/lib/vienna_rna/modules/eval.rb

@@ -3,7 +3,7 @@ module ViennaRna
     attr_reader :mfe
     
     def post_process
-      @mfe = Parser.mfe(@response)
+      @mfe = Parser.rnafold_mfe(@response)
     end
   end
 end

data/lib/vienna_rna/modules/fftbor.rb

@@ -9,21 +9,6 @@ module ViennaRna
       standalone: "FFTbor"
     }
     
-    def run_command(flags = {})
-      flags = { mode: :standalone }.merge(flags)
-      
-      unless MODES[flags[:mode]]
-        STDERR.puts "ERROR: The mode requested (%s) is not available" % flags[:mode]
-      end
-      
-      case mode = flags.delete(:mode)
-      when :standalone then
-        super(flags)
-      when :dispatch then
-        "%s -m 6 -tr 0 -s %s -ss '%s'" % [MODES[mode], data.seq, data.safe_structure]
-      end
-    end
-    
     def partition
       response.split(/\n/).find { |line| line =~ /^Scaling factor.*:\s+(\d+\.\d+)/ }
       BigDecimal.new($1)
@@ -37,32 +22,5 @@ module ViennaRna
     def distribution
       self.class.parse(response).map { |row| BigDecimal.new(row[1]) }
     end
-    
-    def windows
-      # This is starting to feel pretty hackety.
-      response.gsub(/Sum.*\n+Window size:\s+\d+/) { |match| "[:separator:]" + match }.split("[:separator:]").map do |window_response|
-        window_size  = window_response.match(/Window size:\s+(\d+)/)[1].to_i
-        window_index = window_response.match(/Window starting index:\s+(\d+)/)[1].to_i
-        
-        self.class.new(seq: data.seq[window_index - 1, window_size], str: data.safe_structure[window_index - 1, window_size]).tap do |window_run|
-          class << window_run
-            attr_accessor :response, :window_size, :window_index
-          end
-          
-          window_run.response     = window_response
-          window_run.window_size  = window_size
-          window_run.window_index = window_index
-        end
-      end
-    end
-    
-    def compare
-      {
-        dispatch:   self.class.new(data).run(mode: :dispatch).distribution,
-        standalone: self.class.new(data).run(mode: :standalone).distribution
-      }.tap do |hash|
-        hash[:tvd] = Diverge.new(hash[:dispatch], hash[:standalone]).tvd
-      end
-    end
   end
 end

data/lib/vienna_rna/modules/fftbor2d.rb

@@ -0,0 +1,5 @@
+module ViennaRna
+  class Fftbor2d < Fftbor
+    
+  end
+end

data/lib/vienna_rna/modules/fold.rb

@@ -7,12 +7,12 @@ module ViennaRna
     attr_reader :mfe_rna, :structure, :mfe
     
     def post_process
-      structure = @response.split(/\n/).last.gsub(Parser::REGEXP[:mfe], "")
+      structure = Parser.rnafold_mfe_structure(@response)
       
       unless data.seq.length == structure.length
         raise "Sequence: '#{data.seq}'\nStructure: '#{structure}'"
       else
-        @mfe_rna, @structure, @mfe = ViennaRna::Rna.new(data.seq, structure), structure, Parser.mfe(@response)
+        @mfe_rna, @structure, @mfe = ViennaRna::Rna.init_from_string(data.seq, structure), structure, Parser.rnafold_mfe(@response)
       end
     end
     

data/lib/vienna_rna/modules/parser.rb

@@ -5,8 +5,12 @@ module ViennaRna
     }
     
     class << self
-      def mfe(response)
-        response.split(/\n/).last.match(REGEXP[:mfe])[1].to_f
+      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

data/lib/vienna_rna/modules/rna.rb

@@ -2,32 +2,69 @@ module ViennaRna
   class Rna
     include ViennaRna::RnaExtensions
     
-    attr_reader :sequence, :structure
+    attr_reader :sequence, :structure, :raw_data
       
-    def initialize(sequence, structure = nil)
-      if sequence.class == self.class
-        # Too bad you can't do this in a cleaner way without method chaining initialize
-        @sequence  = sequence.sequence
-        @structure = sequence.structure
-      else
-        @sequence  = sequence.upcase
-        @structure = (structure == :mfe ? ViennaRna::Fold.run(seq).structure : structure)
+    class << self
+      def init_from_string(sequence, structure = nil)
+        new(sequence, structure)
+      end
+    
+      def init_from_hash(hash)
+        new(hash[:sequence] || hash[:seq], hash[:structure] || hash[:str], hash)
+      end
+      
+      def init_from_array(array)
+        new(*array)
+      end
+      
+      def init_from_fasta(string)
+        init_from_string(*string.split(/\n/).reject { |line| line.start_with?(">") })
+      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(rna.sequence, rna.structure, rna.raw_data)
+      end
+    end
+    
+    def initialize(sequence, structure, raw_data = {})
+      @sequence, @raw_data = sequence, raw_data
+      
+      @structure = case structure
+      when :empty then empty_structure
+      when :mfe   then ViennaRna::Fold.run(ViennaRna::Rna.init_from_string(seq)).structure
+      when String then structure
       end
     end
-
+    
     alias :seq :sequence
     alias :str :structure
-      
-    def safe_structure
-      structure || empty_structure
+    
+    def inspect
+      case [sequence.present?, structure.present?]
+      when [true, true] then
+        "#<ViennaRna::#{self.class.name} #{seq[0, 20] + (seq.length > 20 ? '...' : '')} #{str[0, 20] + (str.length > 20 ? ' [truncated]' : '')}>"
+      when [true, false] then
+        "#<ViennaRna::#{self.class.name} #{seq[0, 20] + (seq.length > 20 ? '...' : '')}>"
+      when [false, false] then
+        "#<ViennaRna::#{self.class.name}>"
+      end
+    end
+    
+    def write_fa!(filename, comment = "")
+      (File.basename(filename, ".fa") + ".fa").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)       if str
+        end
+      end
     end
+    
+    private
       
     def empty_structure
       "." * seq.length
     end
-    
-    def inspect
-      "#<ViennaRna::#{self.class.name} #{seq[0, 20] + ('...' if seq.length > 20)} #{str[0, 20] + ('[truncated]' if seq.length > 20)}>"
-    end
   end
 end

data/lib/vienna_rna/modules/rna_extensions.rb

@@ -18,7 +18,7 @@ module ViennaRna
     module ClassMethods
       def generate_sequence(sequence_length)
         # 0th order Markov chain w/ uniform probability distribution
-        sequence_length.times.inject("") { |string, _| string + %w[A U C G][rand(4)] }
+        Rna.init_from_string(sequence_length.times.inject("") { |string, _| string + %w[A U C G][rand(4)] })
       end
       
       def shuffle(sequence, token_length = 2)

data/lib/vienna_rna/modules/subopt.rb

@@ -3,7 +3,7 @@ module ViennaRna
     attr_reader :structures
     
     def post_process
-      @structures = @response.split(/\n/)
+      @structures = @response.split(/\n/)[1..-1].map { |output| ViennaRna::Rna.init_from_string(data.seq, output.split(/\s+/).first) }
     end
     
     def bin(count = 1)

data/lib/vienna_rna/modules/utils.rb

@@ -33,10 +33,12 @@ module ViennaRna
       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 800,600")
+              plot.terminal("png size %s" % (options[:dimensions] || "800,600"))
             end
             
             (options[:plot] || {}).keys.each do |option|
@@ -45,7 +47,9 @@ module ViennaRna
 
             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.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
@@ -59,6 +63,8 @@ module ViennaRna
         
         Gnuplot.open do |gnuplot|
           Gnuplot::SPlot.new(gnuplot) do |plot|
+            plot.autoscale
+            
             case options[:output]
             when /file/i then
               plot.output(options[:filename])
@@ -78,6 +84,42 @@ module ViennaRna
         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.merge!({
+          plot: {
+            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, ...]]
+        # This 'twiddle' removes duplicates by adding a very small random number to any repeated value
+        data = data.map { |scores| scores.group_by(&:_ident).values.inject([]) { |array, values| array + (values.size > 1 ? values.map { |i| i + 1e-8 * (rand - 0.5) } : values) } }
+        
+        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

data/lib/vienna_rna/modules/xbor.rb

@@ -12,9 +12,11 @@ module ViennaRna
     def run_command(flags = {})
       file = Tempfile.new("rna")
       file.write("%s\n" % data.seq)
-      file.write("%s\n" % data.safe_structure)
+      file.write("%s\n" % data.str)
       file.close
       
+      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)), 
@@ -22,6 +24,14 @@ module ViennaRna
       ]
     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(ViennaRna::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

data/lib/vienna_rna.rb

@@ -3,6 +3,7 @@ require "bio"
 require "shuffle"
 require "matrix"
 require "gnuplot"
+require "rroc"
 require "active_support/inflector"
 require "active_support/core_ext/class"
 require "active_support/core_ext/module/aliasing"

metadata

@@ -1,80 +1,85 @@
 --- !ruby/object:Gem::Specification
 name: vienna_rna
 version: !ruby/object:Gem::Version
-  version: 0.2.0
-  prerelease: 
+  version: 0.3.0
 platform: ruby
 authors:
 - Evan Senter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-05 00:00:00.000000000 Z
+date: 2013-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bio
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.4.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.4.2
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '3.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '3.2'
 - !ruby/object:Gem::Dependency
   name: shuffle
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: gnuplot
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 2.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 2.5.0
+- !ruby/object:Gem::Dependency
+  name: rroc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.1
 description: A Ruby API for interacting with the Vienna RNA package.
 email: evansenter@gmail.com
 executables: []
@@ -85,6 +90,7 @@ files:
 - lib/vienna_rna/modules/batch.rb
 - lib/vienna_rna/modules/eval.rb
 - lib/vienna_rna/modules/fftbor.rb
+- lib/vienna_rna/modules/fftbor2d.rb
 - lib/vienna_rna/modules/ffthairpin.rb
 - lib/vienna_rna/modules/fftmultiloop.rb
 - lib/vienna_rna/modules/fold.rb
@@ -100,26 +106,25 @@ files:
 - README.md
 homepage: http://rubygems.org/gems/vienna_rna
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Bindings to the Vienna RNA package.
 test_files: []