miga-base 0.7.26.0 → 1.0.0.1

data/utils/enveomics/Scripts/lib/enveomics_rb/rbm.rb

@@ -0,0 +1,49 @@
+require 'enveomics_rb/bm_set'
+
+module Enveomics
+  class RBM
+    attr :seq1, :seq2, :bms1, :bms2
+
+    ##
+    # Initialize RBM object with sequence paths +seq1+ and +seq2+, and
+    # Enveomics::BMset options Hash +bm_opts+
+    def initialize(seq1, seq2, bm_opts = {})
+      @seq1 = seq1
+      @seq2 = seq2
+      @bms1 = Enveomics::BMset.new(seq1, seq2, bm_opts)
+      @bms2 = Enveomics::BMset.new(seq2, seq1, bm_opts)
+      @set = nil
+    end
+
+    ##
+    # Array of Reciprocal Best Enveomics::Match objects
+    def set
+      @set ||= reciprocate!
+    end
+
+    ##
+    # Number of reciprocal best matches found
+    def count
+      set.count
+    end
+
+    ##
+    # Find reciprocal best matches and return the subset of +bms1+ that
+    # is reciprocal with +bms2+
+    def reciprocate!
+      bms1.each.select do |bm|
+        bms2[bm.sbj] && bm.qry == bms2[bm.sbj].sbj
+      end
+    end
+
+    ##
+    # Enumerate RBMs and yield +blk+
+    def each(&blk)
+      if block_given?
+        set.each { |bm| blk.call(bm) }
+      else
+        to_enum(:each)
+      end
+    end
+  end
+end

data/utils/enveomics/Scripts/lib/enveomics_rb/remote_data.rb

@@ -0,0 +1,74 @@
+
+#
+# @author: Luis M. Rodriguez-R
+# @license: artistic license 2.0
+#
+
+require "enveomics_rb/enveomics"
+use "restclient"
+use "json"
+
+class RemoteData
+  # Class-level variables
+  @@EUTILS = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils"
+  @@EBIREST = "http://www.ebi.ac.uk/Tools"
+   
+  # Class-level methods
+  def self.eutils(script, params={}, outfile=nil)
+    response = nil
+    10.times do
+      begin
+        response = RestClient.get "#{@@EUTILS}/#{script}", {:params=>params}
+      rescue => err
+        warn "Request failed #{response.nil? ? "without error code" :
+          "with error code #{response.code}"}."
+        next
+      end
+      break if response.code == 200
+    end
+    abort "Unable to reach NCBI EUtils, error code #{response.code}." unless
+      response.code == 200
+    unless outfile.nil?
+      ohf = File.open(outfile, "w")
+      ohf.print response.to_s
+      ohf.close
+    end
+    response.to_s
+  end
+  def self.efetch(*etc)
+    eutils "efetch.fcgi", *etc
+  end
+  def self.elink(*etc)
+    eutils "elink.fcgi", *etc
+  end
+  def self.esummary(*etc)
+    eutils "esummary.fcgi", *etc
+  end
+  def self.update_gi(db, old_gi)
+    summ = JSON.parse RemoteData.esummary({:db=>db, :id=>old_gi,
+      :retmode=>"json"})
+    return nil,nil if summ["result"].nil? or summ["result"][old_gi.to_s].nil?
+    new_acc = summ["result"][old_gi.to_s]["replacedby"]
+    new_gi = (new_acc.nil? ? nil :
+      RemoteData.efetch({:db=>db, :id=>new_acc, :rettype=>"gi"}))
+    return new_gi,summ["result"][old_gi.to_s]["status"]
+  end
+  def self.ebiFetch(db, id, format, outfile=nil)
+    url = "#{@@EBIREST}/dbfetch/dbfetch/#{db}/#{id}/#{format}"
+    response = RestClient::Request.execute(:method=>:get,
+      :url=>url, :timeout=>600)
+    raise "Unable to reach EBI REST client, error code " +
+      response.code.to_s + "." unless response.code == 200
+    response.to_s
+  end
+  def self.ebiseq2taxid(id,db)
+    doc = RemoteData.ebiFetch(db, id, "annot").split(/[\n\r]/)
+    ln = doc.grep(/^FT\s+\/db_xref="taxon:/).first
+    ln = doc.grep(/^OX\s+NCBI_TaxID=/).first if ln.nil?
+    return nil if ln.nil?
+    ln.sub!(/.*(?:"taxon:|NCBI_TaxID=)(\d+)["; ].*/, "\\1")
+    return nil unless ln =~ /^\d+$/
+    ln
+  end
+end
+

data/utils/enveomics/Scripts/lib/enveomics_rb/seq_range.rb

@@ -0,0 +1,237 @@
+
+##### CLASSES:
+# SeqRange.parse(str): Initializes a new SeqRange from a string. A SeqRange is a
+#    representation of any collection of coordinates in a given sequence.
+#    Coordinates here are 1-based and base-located. Admitedly, the
+#    0-based/interbase-located system is much more convenient for range
+#    operations, but GenBank (together with most common Software) is built on
+#    the 1-based/base-located system.
+# str: A string describing the sequence range as in GenBank records.
+#    Note that "ID:location" notation is NOT supported by this implementation,
+#    althought it is permitted by GenBank. Some examples of valid `str`:
+#       "<1..123"
+#       "complement(3..6)"
+#       "join(complement(join(13..43,complement(45..46),complement(1..12),
+#           <1..12)),12..15,13..22)"
+#    The last one is valid, but once parsed it's internally simplified as:
+#       "join(complement(<1..12),1..12,45..46,complement(13..43),12..15,13..22)"
+#    Which is exactly equivalent. The common (but non-GenBank-compliant)
+#    practice of inverting coordinates instead of using the `complement()`
+#    operator is also supported. For example:
+#       "123..3"
+#    Is interpreted as:
+#       "complement(3..123)"
+# See also http://www.insdc.org/files/feature_table.html
+# 
+# SeqRange.new(c): Initializes a new SeqRange from an object.
+# c: Any object supported by the `<<` operator, or `nil` to create an empty
+#    SeqRange.
+# 
+# See also ContigSeqRange.parse.
+class SeqRange
+   # Class-level
+   def self.parse(str)
+      str.gsub!(/[^A-Za-z0-9\.\(\)<>,]/,"")
+      sr = nil
+      if str =~ /^join\((.+)\)$/i
+	 str1 = $1
+	 str2 = ""
+	 sr = SeqRange.new
+	 parens = 0
+	 str1.each_char do |chr|
+	    if chr=="," and parens==0
+	       sr += SeqRange.parse(str2)
+	       str2 = ""
+	       next
+	    elsif chr=="("
+	       parens += 1
+	    elsif chr==")"
+	       parens -= 1
+	       raise "Unbalanced parenthesis in '#{str1}'." if parens < 0
+	    end
+	    str2 += chr
+	 end
+	 sr += SeqRange.parse(str2) unless str2.empty?
+	 sr
+      elsif str =~ /^complement\((.+)\)$/i
+	 sr = SeqRange.parse($1)
+	 sr.reverse!
+	 sr
+      else
+	 sr = SeqRange.new(ContigSeqRange.parse(str))
+      end
+      sr
+   end
+   # Instance-level
+   attr_reader :contig
+   def initialize(c=nil)
+      @contig = []
+      self << c unless c.nil?
+   end
+   def leftmost; contig.map{ |c| c.left }.min; end
+   def rightmost; contig.map{ |c| c.right }.max; end
+   def size; contig.map{ |c| c.size }.inject(0,:+); end
+   def +(sr)
+      return(self + SeqRange.new(sr)) if sr.is_a? ContigSeqRange
+      raise "Unsupported operation '+' with class #{sr.class.to_s}." unless
+	 sr.is_a? SeqRange
+      out = SeqRange.new(self)
+      out << sr
+      out
+   end
+   def /(sr)
+      if sr.is_a? SeqRange
+	 sr2 = sr.sort.compact
+	 raise "Denominator is not a contiguous domain." unless sr2.size==1
+	 return(self/sr2.contig.first)
+      end
+      raise "Unsupported operation '/' with class #{sr.class.to_s}" unless
+	 sr.is_a? ContigSeqRange
+      raise "Denominator doesn't span the whole domain of numerator." unless
+	 sr.left <= leftmost and sr.right >= rightmost
+      i = ContigSeqRange.IGNORE_STRAND
+      ContigSeqRange.IGNORE_STRAND = false
+      range = self.sort.compact.size
+      ContigSeqRange.IGNORE_STRAND = i
+      range.to_f / sr.size
+   end
+   def <<(c)
+      if c.is_a? ContigSeqRange
+	 @contig << c
+      elsif c.is_a? SeqRange
+	 @contig += c.contig
+      elsif c.is_a? Array
+	 raise "Array must contain only objects of class ContigSeqRange." unless
+	    c.map{ |cc| cc.is_a? ContigSeqRange }.all?
+	 @contig += c
+      else
+	 raise "Unsupported operation '<<' with class #{c.class.to_s}."
+      end
+   end
+   def reverse ; SeqRange.new(self).reverse! ; end
+   def sort ; SeqRange.new(self).sort! ; end
+   def compact ; SeqRange.new(self).compact! ; end
+   def reverse!
+      @contig.each{ |c| c.reverse! }
+      @contig.reverse!
+      self
+   end
+   def sort!
+      @contig.sort!{ |x,y| x.left <=> y.left }
+      self
+   end
+   def compact!
+      return self if contig.size < 2
+      clean = false
+      while not clean
+	 clean = true
+	 (2 .. contig.size).each do |i|
+	    next unless contig[i-2].reverse? == contig[i-1].reverse?
+	    next unless contig[i-2].contig? contig[i-1]
+	    contig[i-2] += contig[i-1]
+	    contig[i-1] = nil
+	    clean = false
+	    break
+	 end
+	 @contig.compact!
+      end
+      self
+   end
+   def to_s
+      o = contig.map{ |c| c.to_s }.join(",")
+      o = "join(#{o})" if contig.size > 1
+      o
+   end
+end
+
+
+# ContigSeqRange.parse(str): Initializes a new ContigSeqRange from a string. A 
+#    ContigSeqRange is a primitive of `SeqRange` that doesn't support the
+#    `join()` operator. Other than that, syntax is identical to `SeqRange`.
+# str: A string describing the sequence range as in GenBank records (except
+#    `join()`).
+#
+# ContigSeqRange.new(a,b): Initializes a new ContigSeqRange from the
+#    coordinates as integers.
+# a: Start of the range.
+# b: End of the range. If a>b, the `complement()` operator is assumed.
+#
+# ContigSeqRange.IGNORE_STRAND = true: Use this pragma to ignore strandness.
+#    If set, it globally affects the behavior of of the class. Note that
+#    `SeqRange` instances contain a collection of `ContigSeqRange` objects, so
+#    that class is also affected.
+class ContigSeqRange
+   # Class-level
+   @@IGNORE_STRAND = false
+   def self.IGNORE_STRAND=(v); @@IGNORE_STRAND = !!v ; end
+   def self.IGNORE_STRAND; @@IGNORE_STRAND ; end
+   def self.parse(str)
+      str.downcase!
+      m = %r{^
+	 (?<c>complement\()?	# Reverse
+	 (?<lt><?)		# Open-ended to the left
+	 (?<left>\d+)		# Left coordinate
+	 (
+	    \.\.\.?		# 2 or 3 dots
+	    (?<gt1>>?)		# Open-ended to the right
+	    (?<right>\d+)	# Right coordinate
+	 )?
+	 (?<gt2>>?)		# Open-ended to the right
+	 \)?			# If reverse
+      $}x.match(str)
+      raise "Cannot parse range: #{str}." if m.nil?
+      c = ContigSeqRange.new(m[:left].to_i, m[:right].to_i)
+      c.open_left = true if m[:lt]=="<"
+      c.open_right = true if m[:gt1]==">" or m[:gt2]==">"
+      c.reverse! if m[:c]=="complement("
+      c
+   end
+   # Instance-level
+   attr_accessor :open_left, :open_right
+   attr_reader :coords
+   def initialize(a,b)
+      @coords = [[a,b].min, [a,b].max]
+      @open_left = false
+      @open_right = false
+      @reverse = (a > b)
+   end
+   def from; coords[ reverse ? 1 : 0 ] ; end
+   def to; coords[ reverse ? 0 : 1 ] ; end
+   def left; coords[0] ; end
+   def right; coords[1] ; end
+   def size; right-left+1 ; end
+   def reverse?; @reverse ; end
+   def reverse!
+      @reverse = ! reverse? unless @@IGNORE_STRAND
+      self
+   end
+   def overlap?(sr) !(right < sr.left or left > sr.right) ; end
+   def contig?(sr) !(right+1 < sr.left or left-1 > sr.right) ; end
+   def +(sr)
+      raise "Unsupported operation '+' with class #{sr.class.to_s}" unless
+	 sr.is_a? ContigSeqRange
+      raise "Non-contiguous ranges cannot be added." unless contig? sr
+      raise "Ranges in different strands cannot be added." unless
+	 reverse? == sr.reverse?
+      out = ContigSeqRange.new([left,sr.left].min, [right,sr.right].max)
+      out.reverse! if reverse?
+      out.open_left=true if (left < sr.left ? self : sr).open_left
+      out.open_right=true if (right > sr.right ? self : sr).open_right
+      out
+   end
+   def to_s
+      o = ""
+      o += "<" if open_left
+      o += left.to_s
+      if left == right
+	 o += ">" if open_right
+      else
+	 o += ".."
+	 o += ">" if open_right
+	 o += right.to_s
+      end
+      o = "complement(#{o})" if reverse?
+      o
+   end
+end
+

data/utils/enveomics/Scripts/lib/enveomics_rb/stats.rb

@@ -0,0 +1,3 @@
+require 'enveomics_rb/stats/rand'
+require 'enveomics_rb/stats/sample'
+

data/utils/enveomics/Scripts/lib/enveomics_rb/stats/rand.rb

@@ -0,0 +1,31 @@
+
+module Enveomics
+  module Stats
+    class << self
+      # Generates a random number from the +dist+ distribution with +params+
+      # parameters. This is simply a wrapper to the r_* functions below.
+      def rand(dist = :unif, *params)
+        send("r_#{dist}", *params)
+      end
+
+      # Generates a random number from the uniform distribution between +min+
+      # and +max+. By default generates random numbers between 0.0 and 1.0.
+      def r_unif(min = 0.0, max = 1.0)
+        min + (max - min) * Random::rand
+      end
+      
+      # Generates a random number from the geometric distribution with support
+      # {0, 1, 2, ...} and probability of success +p+.
+      def r_geom(p)
+        (Math::log(1.0 - rand) / Math::log(1.0 - p) - 1.0).ceil
+      end
+
+      # Generates a random number from the shifted geometric distribution with
+      # support {1, 2, 3, ...} and probability of success +p+.
+      def r_sgeom(p)
+        (Math::log(1.0 - rand) / Math::log(1.0 - p)).ceil
+      end
+    end
+  end
+end
+

data/utils/enveomics/Scripts/lib/enveomics_rb/stats/sample.rb

@@ -0,0 +1,152 @@
+
+module Enveomics
+  module Stats
+    # Descriptive statistics for a given sample
+    class Sample
+      attr :x
+      attr :opts
+
+      # Initialize Enveomics::Stats::Sample with numeric vector +x+ and options
+      # Hash +opts+ supporting the keys:
+      # - +effective_range+: Range where values fall (by default: range of +x+)
+      # - +histo_bin_size+: Width of histogram widths
+      #   (by default: 1/50th of +effective_range+)
+      def initialize(x, opts = {})
+        raise 'Cannot initialize an empty sample' if x.empty?
+        @x = x.map(&:to_f)
+        @opts = opts
+      end
+
+      # Size of the sample
+      def n
+        x.size
+      end
+
+      # Estimates the sample mean
+      def mean
+        @mean ||= x.inject(:+) / n
+      end
+
+      # Estimates the mean of the square of the sample
+      def square_mean
+        @square_mean ||= x.map { |i| i**2 }.inject(:+) / n
+      end
+
+      # Estimates the unbiased sample variance
+      def var
+        @var ||= (square_mean - mean ** 2) * n / (n - 1)
+      end
+
+      # Estimates the unbiased sample standard deviation
+      def sd
+        @sd ||= var ** 0.5
+      end
+
+      # --- Higher moments ---
+
+      # Estimate sample skewness
+      def skewness
+        return 0.0 if n == 1
+        cubed_dev = x.inject(0.0) { |sum, i| sum + (i - mean) ** 3 }
+        cubed_dev / ((n - 1) * (sd ** 3))
+      end
+
+      # Estimate sample excess kurtosis
+      def kurtosis
+        return 0.0 if n == 1
+        quart_dev = x.inject(0.0) { |sum, i| sum + (i - mean)**4 }
+        quart_dev / ((n - 1) * (sd**4))
+      end
+
+      # --- Ranges ---
+
+      # Range effectively considered
+      def effective_range
+        @opts[:effective_range] ||= [nil, nil]
+        @opts[:effective_range][0] ||= x.min
+        @opts[:effective_range][1] ||= x.max
+        @opts[:effective_range]
+      end
+
+      # Size of the effective range
+      def effective_range_size
+        effective_range[1] - effective_range[0]
+      end
+
+      # --- Histograms ---
+
+      # Size of each histogram bin
+      def histo_bin_size
+        @opts[:histo_bin_size] ||= effective_range_size / 50.0
+      end
+
+      # Calculate histogram ranges without checking for cached value
+      #
+      # Use #histo_ranges instead
+      def calculate_histo_ranges
+        rng = [[effective_range[1], effective_range[1] - histo_bin_size]]
+        while rng[rng.size - 1][1] > effective_range[0]
+          rng << [rng[rng.size - 1][1], rng[rng.size - 1][1] - histo_bin_size]
+        end
+        rng
+      end
+
+      # Histogram ranges as an array of two-entry arrays where the fist entry
+      # is the closed-ended maximum value (inclusive) of the range and the
+      # second entry is the open-ended minimum value (non-inclusive) of the
+      # range. The array is sorted from maximum to minimum
+      #
+      # Something like: +[[100.0, 99.0], [99.0, 98.0], ...]+, representing the
+      # ranges: {[100, 99), [99, 98), ...}
+      #
+      # The bin width is determined by #hist_bin_size
+      def histo_ranges
+        @histo_ranges ||= calculate_histo_ranges
+      end
+
+      # Mid-points of the histogram ranges from #histo_ranges, returns
+      # and array of Float
+      def histo_mids
+        @histo_mids ||= histo_ranges.map { |x| (x[0] + x[1]) / 2 }
+      end
+
+      # Calculate the histogram counts withouth checking cached value
+      #
+      # Use #histo_count instead
+      def calculate_histo_counts
+        counts = []
+        xx = x.dup
+        histo_ranges.each do |i|
+          counts << xx.size - xx.delete_if { |j| j > i[1] }.size
+        end
+        counts
+      end
+
+      # Histogram counts in the ranges determined by #histo_ranges
+      def histo_counts
+        @histo_counts ||= calculate_histo_counts
+      end
+
+      # --- Bimodality coefficients ---
+
+      # Sarle's sample bimodality coefficient b
+      def sarle_bimodality
+        (skewness**2 + 1) /
+          (kurtosis + (3 * ((n - 1)**2)) / ((n - 2) * (n - 3)))
+      end
+
+      # de Michele & Accantino (2014) B index
+      # DOI: 10.1371%2Fjournal.pone.0091195
+      def dma_bimodality
+        (mean - dma_mu_M).abs
+      end
+
+      # µ_M index proposed by Michele & Accantino (2014)
+      # DOI: 10.1371%2Fjournal.pone.0091195
+      def dma_mu_M
+        histo_counts.each_with_index.map { |m, k| m * histo_mids[k] }.inject(:+) / n
+      end
+    end
+  end
+end
+