wrnap 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 64536fb0d398fb7708119acac77f2769d6074344
-  data.tar.gz: 9f83cf3dedfd4ebac3ede5bf2e25031b573db68c
+  metadata.gz: 886697f970124a5b27d1149141ebaadfd8f275c2
+  data.tar.gz: 19afc74cff392c61f3c84bf12b39db74252fcb96
 SHA512:
-  metadata.gz: baf4553c3c45053b29b634b8190df732929e3b5bee593aa150af19668e312cec8266f87aa75f87197b2d6407b32527e21cdceb9a0b2631dcde38927b38eadb3a
-  data.tar.gz: c4894a9c75dc40054b92e17352d2d54dcb44b583f6ee02c8bc9adf9227393d37c2f67ec69670476d3b55fa971e4cfe048a6a079f86f2af0804a07fca5cce4157
+  metadata.gz: cd86a11763b4770bc7d4af245c36dc647b326870c0e2c9e3f0ab39b0c9a99cfd6db2722c5f72ee176635b4c5f99ffd33ea7cc8805fc24bf411f736eeef0efc0d
+  data.tar.gz: 085d7434dbe7669336a9e858e7dc11c6a12d856e837306bc703596539923a1919f97b819a2878173cb84f02995d585b2b134ab4d2bd7aaa22238753466d6dff0

data/lib/wrnap/global/rna.rb

@@ -2,39 +2,39 @@ module Wrnap
   module Global
     class Rna
       include RnaExtensions
-    
+
       attr_accessor :comment
       attr_reader :sequence, :structure, :second_structure
-      
+
       class << self
         def init_from_string(sequence, structure = nil, second_structure = nil, comment = nil)
           new(
-            sequence:         sequence, 
-            structure:        structure, 
+            sequence:         sequence,
+            structure:        structure,
             second_structure: second_structure,
             comment:          comment
           )
         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], 
+            sequence:         hash[:sequence]         || hash[:seq],
+            structure:        hash[:structure]        || hash[:str_1] || hash[:str],
+            second_structure: hash[:second_structure] || hash[:str_2],
             comment:          hash[:comment]          || hash[:name]
           )
         end
-      
+
         def init_from_array(array)
           init_from_string(*array)
         end
-      
+
         def init_from_fasta(string)
           if File.exist?(string)
             comment = File.basename(string, string.include?(?.) ? ".%s" % string.split(?.)[-1] : "")
             string  = File.read(string).chomp
           end
-          
+
           init_from_string(*string.split(/\n/).reject { |line| line.start_with?(">") }[0, 3]).tap do |rna|
             if (line = string.split(/\n/).first).start_with?(">") && !(file_comment = line.gsub(/^>\s*/, "")).empty?
               rna.comment = file_comment
@@ -43,35 +43,35 @@ module Wrnap
             end
           end
         end
-    
+
         def init_from_self(rna)
           # This happens when you call a Wrnap library function with the output of something like Wrnap::Fold.run(...).mfe
           new(
-            sequence:         rna.sequence, 
-            strucutre:        rna.structure, 
-            second_strucutre: rna.second_structure, 
+            sequence:         rna.sequence,
+            strucutre:        rna.structure,
+            second_strucutre: rna.second_structure,
             comment:          rna.comment
           )
         end
-      
+
         alias_method :placeholder, :new
       end
-    
+
       def initialize(sequence: "", structure: "", second_structure: "", comment: "")
         @sequence, @comment = sequence.kind_of?(Rna) ? sequence.seq : sequence, comment
-      
+
         [:structure, :second_structure].each do |structure_symbol|
           instance_variable_set(
-            :"@#{structure_symbol}", 
+            :"@#{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
-            when Hash   then 
+            when Hash   then
               if structure_value.keys.count > 1
                 Wrnap.debugger { "The following options hash has more than one key. This will probably produce unpredictable results: %s" % structure_value.inspect }
               end
-              
+
               RNA(sequence).run(*structure_value.keys, *structure_value.values).mfe_rna.structure
             end
           )
@@ -80,36 +80,36 @@ module Wrnap
         if str && seq.length != str.length
           Wrnap.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
           Wrnap.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
       alias :name  :comment
-    
+
       def empty_structure
         "." * seq.length
       end
-      
+
       alias :empty_str :empty_structure
-      
+
       def one_structure(structure_1)
         self.class.init_from_string(seq, structure_1.is_a?(Symbol) ? send(structure_1) : structure_1, nil, name)
       end
-      
+
       def two_structures(structure_1, structure_2)
         self.class.init_from_string(
-          seq, 
+          seq,
           *[structure_1, structure_2].map { |argument| argument.is_a?(Symbol) ? send(argument) : argument },
           name
         )
       end
-    
+
       def write_fa!(filename)
         filename.tap do |filename|
           File.open(filename, ?w) do |file|
@@ -120,7 +120,7 @@ module Wrnap
           end
         end
       end
-    
+
       def temp_fa_file!
         write_fa!(Tempfile.new("rna")).path
       end
@@ -128,7 +128,7 @@ module Wrnap
       def run(package_name, options = {})
         Wrnap::Package.lookup(package_name).run(self, options)
       end
-      
+
       def method_missing(name, *args, &block)
         if (name_str = "#{name}") =~ /^run_\w+$/
           run(name_str.gsub(/^run_/, ""), *args)
@@ -145,4 +145,4 @@ module Wrnap
       end
     end
   end
-end
+end

data/lib/wrnap/package/fft_mfpt.rb

@@ -5,17 +5,25 @@ module Wrnap
   module Package
     class FftMfpt < Base
       self.executable_name = "FFTmfpt"
-      
+
+      self.default_flags = ->(context, flags) do
+        {
+          "-fftbor2d-i" => context.data.seq,
+          "-fftbor2d-j" => context.data.str_1,
+          "-fftbor2d-k" => context.data.str_2,
+          "-mfpt-x"     => true
+        }
+      end
+      self.quote_flag_params = %w|-fftbor2d-i -fftbor2d-j -fftbor2d-k|
+
       attr_reader :mfpt
-    
-      def run_command(flags)      
-        "%s %s %s" % [
-          exec_name, 
-          stringify_flags(flags), 
-          data.temp_fa_file!
-        ]
+
+      def run_command(flags)
+        Wrnap.debugger { "Running #{exec_name} on #{data.inspect}" }
+
+        "%s %s" % [exec_name, stringify_flags(flags)]
       end
-    
+
       def post_process
         @mfpt = response.to_f
       end

data/lib/wrnap/package/population.rb

@@ -33,22 +33,29 @@ module Wrnap
         def equilibrium(percentile: 95, window_size: 5, epsilon: 1e-4)
           start       = proportion_points.first
           stop        = proportion_points.last
-          sign        = stop > start ? :increasing : :decreasing
-          # If the population is increasing over time, we want the 95%, otherwise we want the 5%
-          spread_100  = (start.zero? || stop.zero? ? [start, stop].max : (stop / start).abs) / 100
-          # Look for the first index at the percentile we're interested in, and scan to the right from there.
-          start_index = proportion_points.each_with_index.find do |proportion, i|
-            case sign
-            when :increasing then proportion > (stop - (spread_100 * (100 - percentile)))
-            when :decreasing then proportion < (stop + (spread_100 * (100 - percentile)))
+
+          if start != stop
+            sign = stop > start ? :increasing : :decreasing
+            # If the population is increasing over time, we want the 95%, otherwise we want the 5%
+            spread_100  = (start.zero? || stop.zero? ? [start, stop].max : (stop / start).abs) / 100
+            # Look for the first index at the percentile we're interested in, and scan to the right from there.
+            start_index = proportion_points.each_with_index.find do |proportion, i|
+              case sign
+              when :increasing then proportion > (stop - (spread_100 * (100 - percentile)))
+              when :decreasing then proportion < (stop + (spread_100 * (100 - percentile)))
+              end
+            end.last
+
+            # The first slice starting at x we find where abs(p(x + i), p(x)) < epslion for all 1 <= x < window_size is equilibrium,
+            # and we return that time point.
+            equilibrium_time = proportion_over_time[start_index..-1].each_cons(window_size).find do |proportion_slice|
+              proportion_slice.all? { |time, proportion| (proportion - proportion_slice.first.last).abs < epsilon }
             end
-          end.last
 
-          # The first slice starting at x we find where abs(p(x + i), p(x)) < epslion for all 1 <= x < window_size is equilibrium,
-          # and we return that time point.
-          proportion_over_time[start_index..-1].each_cons(window_size).find do |proportion_slice|
-            proportion_slice.all? { |time, proportion| (proportion - proportion_slice.first.last).abs < epsilon }
-          end.first.first
+            equilibrium_time ? 10 ** equilibrium_time.first.first : -1
+          else
+            -1
+          end
         end
 
         def time_points; proportion_over_time.map(&:first); end

data/lib/wrnap/package/spectral.rb

@@ -1,24 +1,25 @@
 module Wrnap
   module Package
-    class Spectral < Base      
-      self.default_flags = ->(context, flags) { { seq: context.data.seq, step_size: "1e-2" } }
-      
+    class Spectral < Base
+      self.default_flags = ->(context, flags) do
+        {
+          s: context.data.seq,
+          k: context.data.str_1,
+          l: context.data.str_2
+        }
+      end
+      self.quote_flag_params = %i|s k l|
+
       attr_reader :eigenvalues, :time_kinetics
-    
+
       def run_command(flags)
-        "%s %s" % [
-          exec_name, 
-          stringify_flags(flags)
-        ]
+        Wrnap.debugger { "Running #{exec_name} on #{data.inspect}" }
+
+        "%s %s" % [exec_name, stringify_flags(flags)]
       end
-    
+
       def post_process
-        if flags.keys.include?(:eigen_only)
-          @eigenvalues = response.split(?\n).map(&:to_f).sort_by(&:abs)
-        else
-          @time_kinetics = response.split(?\n).map { |line| line.split(?\t).map(&:to_f) }
-        end
       end
     end
   end
-end
+end

data/lib/wrnap/version.rb

@@ -1,3 +1,3 @@
 module Wrnap
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/wrnap.rb

@@ -1,3 +1,4 @@
+require "yaml"
 require "benchmark"
 require "set"
 require "shuffle"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wrnap
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Evan Senter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-10 00:00:00.000000000 Z
+date: 2014-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler