miga-base 0.7.26.3 → 1.0.0.sr1

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

@@ -0,0 +1,175 @@
+
+require 'enveomics_rb/enveomics'
+require 'enveomics_rb/match'
+use 'tmpdir'
+use 'shellwords'
+
+module Enveomics
+  class BMset
+    attr :qry, :sbj, :set, :opt
+
+    ##
+    # Initialize Enveomics::BMset object with sequence paths +qry+ and +sbj+,
+    # and options Hash +opts+ (see #opt for supported options) with Symbol keys
+    def initialize(qry, sbj, opts = {})
+      @qry = qry
+      @sbj = sbj
+      @set = nil
+      @opt = opts
+    end
+
+    ##
+    # Returns option with key +k+ as defined by #initialize or by default
+    # Supported options include [defaults in brackets]:
+    # - len   [0]:   Minimum alignment length in residues
+    # - id    [0.0]: Minimum alignment identity in percent
+    # - fract [0.0]: Minimum alignment length as fraction of the query
+    # - score [0.0]: Minimum alignment score in bits
+    # - nucl  [false]: The sequences are in nucleotides
+    # - thr   [1]:   Number of threads to use
+    # - bin   ['']:  Path to the directory containing binaries
+    # - program [:blast+]: Search engine to use
+    def opt(k)
+      @defaults ||= {
+        len: 0, id: 0.0, fract: 0.0, score: 0.0,
+        nucl: false, thr: 1, bin: '', program: :'blast+'
+      }
+      k = k.to_sym
+      @opt[k] = @defaults[k] if @opt[k].nil?
+      @opt[k]
+    end
+
+    ##
+    # Array of Enveomics::Match objects
+    def set
+      match_and_filter! if @set.nil?
+      @set
+    end
+
+    ##
+    # Returns the best match of query +qry+ as Enveomics::Match or nil if
+    # no qualifying match was found
+    def [](qry)
+      set[qry]
+    end
+
+    ##
+    # Number of matches found
+    def count
+      set.count
+    end
+
+    ##
+    # Execute search and filter matches 
+    def match_and_filter!
+      @set = {}
+      match!.each do |match|
+        # Already a better match?
+        next if self[match.qry] && self[match.qry].score >= match.score
+
+        # Is this a good enough match?
+        next unless %i[len id score fract].all? do |metric|
+          match.send(metric) >= opt(metric)
+        end
+
+        # Save match
+        @set[match.qry] = match
+      end
+    end
+
+    ##
+    # Find all matches and return as an array of Enveomics::Match objects
+    def match!
+      y = []
+      Dir.mktmpdir do |dir|
+        # Determine commands
+        say('Temporal directory: ', dir)
+        db_path = File.join(dir, 'sbj.db')
+        out_path = File.join(dir, 'out.tsv')
+        cmds = []
+        case opt(:program)
+        when :blast
+          cmds << [
+            'formatdb', '-i', sbj, '-n', db_path, '-l', File.join(dir, 'log'),
+            '-p', opt(:nucl) ? 'F' : 'T'
+          ]
+          cmd << [
+            'blastall', '-p', opt(:nucl) ? 'blastn' : 'blastp', '-d', db_path,
+            '-i', qry, '-v', '1', '-b', '1', '-a', opt(:thr).to_s, '-m', '8',
+            '-o', out_path
+          ]
+        when :'blast+'
+          cmds << [
+            'makeblastdb', '-in', sbj, '-out', db_path,
+            '-dbtype', opt(:nucl) ? 'nucl' : 'prot'
+          ]
+          cmds << [
+            opt(:nucl) ? 'blastn' : 'blastp', '-db', db_path, '-query', qry,
+            '-num_threads', opt(:thr).to_s, '-out', out_path, '-outfmt',
+            '6 qseqid sseqid pident length mismatch gapopen qstart qend ' \
+              'sstart send evalue bitscore qlen slen'
+          ]
+        when :diamond
+          raise Enveomics::OptionError.new(
+            'Unsupported search engine diamond for nucleotides'
+          ) if opt(:nucl)
+          cmds << [
+            'diamond', 'makedb', '--in', sbj, '--db', db_path,
+            '--threads', opt(:thr).to_s
+          ]
+          cmds << [
+            'diamond', 'blastp', '--threads', opt(:thr).to_s,
+            '--db', db_path, '--query', qry, '--daa', "#{out_path}.daa",
+            '--quiet', '--sensitive'
+          ]
+          cmds << [
+            'diamond', 'view', '--daa', "#{out_path}.daa", '--out', out_path,
+            '--quiet', '--outfmt'
+          ] + %w[6 qseqid sseqid pident length mismatch gapopen qstart] +
+              %w[qend sstart send evalue bitscore qlen slen]
+        when :blat
+          cmds << ['blat', sbj, qry, '-out=blast8', out_path]
+          cmds[0] << '-prot' unless opt(:nucl)
+        else
+          raise Enveomics::OptionError.new(
+            "Unsupported search engine: #{opt(:program)}"
+          )
+        end
+
+        # Run commands
+        say('Running comparison')
+        say('Query: ', qry)
+        say('Subject: ', sbj)
+        cmd_err = File.join(dir, 'err')
+        begin
+          cmds.each do |cmd|
+            cmd[0] = File.join(opt(:bin), cmd[0]) unless opt(:bin) == ''
+            run_cmd(cmd, stderr: cmd_err)
+          end
+        rescue Enveomics::CommandError => e
+          $stderr.puts e
+          $stderr.puts ''
+          $stderr.puts '[ Error log ]'
+          $stderr.puts File.read(cmd_err)
+          exit
+        end
+
+        # Parse output
+        File.open(out_path, 'r') do |fh|
+          fh.each { |ln| y << Enveomics::Match.new(ln) }
+        end
+      end
+      y
+    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/enveomics.rb

@@ -1,24 +1,24 @@
 
-#
-# @author: Luis M. Rodriguez-R
-# @license: artistic license 2.0
-#
+require 'enveomics_rb/utils'
+use 'optparse'
+ARGV << '-h' if ARGV.empty?
 
-require "optparse"
-ARGV << "-h" if ARGV.size==0
+module Enveomics
+  class << self
+    def opt_banner(opt, banner, usage = nil)
+      opt.version ||= $VERSION
+      usage ||= "#{opt.program_name}.rb [options]"
+      opt.banner = <<~BANNER
 
-def use(gems, mandatory=true)
-  gems = [gems] unless gems.is_a? Array
-  begin
-    require "rubygems"
-    while ! gems.empty?
-      require gems.shift
+        [Enveomics Collection: #{opt.program_name} #{opt.version}]
+
+        #{banner}
+
+        Usage
+          #{usage}
+
+      BANNER
     end
-    return true
-  rescue LoadError
-    abort "\nUnmet requirements, please install required gems:" +
-      gems.map{ |gem| "\n   gem install #{gem}" }.join + "\n\n" if mandatory
-    return false
   end
 end
 

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

@@ -0,0 +1,17 @@
+
+module Enveomics
+  class Error < RuntimeError
+  end
+
+  class CommandError < Error
+  end
+
+  class OptionError < Error
+  end
+
+  class UnimplementedError < Error
+  end
+
+  class ParseError < Error
+  end
+end

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

@@ -0,0 +1,30 @@
+
+require 'enveomics_rb/stats/sample'
+
+module Enveomics
+  # Calculate Gaussian Mixture Models by Expectation Maximization
+  class GmmEm
+    attr :sample
+    attr :components
+    attr :opts
+
+    # Initialize Enve::GmmEm object from numeric array +x+, +components+
+    # gaussian components (an Integer), and options hash +opts+ with supported
+    # Symbol keys:
+    # - ll_delta_converge: Maximum change in LL to consider convergence
+    #   (by default: 1e-15)
+    # - max_iter: Maximum number of EM iterations (by default: 1_000)
+    # - init_mu: Initial components means as numeric array
+    # - init_sigma: Initial components standard deviation as numeric array
+    # - init_alpha: Initial components fractions as numeric array adding up to 1
+    def initialize(x, components = 2, opts = {})
+      @sample = Enve::Stats::Sample.new(x)
+      @opts = opts
+      @opts[:ll_delta_convergence] ||= 1e-15
+      @opts[:max_iter] ||= 1_000
+    end
+
+    
+  end
+end
+

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

@@ -0,0 +1,63 @@
+
+module Enveomics
+  ##
+  # A simple object representing a sequence match from a search engine
+  # supporting tabular BLAST output
+  class Match
+    attr :row
+
+    ##
+    # Initialize Enveomics::Match object from a tabular blast line String +ln+
+    def initialize(ln)
+      @row = ln.chomp.split("\t")
+    end
+
+    def qry
+      row[0]
+    end
+
+    def sbj
+      row[1]
+    end
+
+    def id
+      @id ||= row[2].to_f
+    end
+
+    def len
+      @len ||= row[3].to_i
+    end
+
+    def evalue
+      @evalue ||= row[9].to_f
+    end
+
+    def score
+      @score ||= row[10].to_f
+    end
+
+    def qry_len
+      @qry_len ||= row[12].to_i
+    end
+
+    def sbj_len
+      @sbj_len ||= row[13].to_i
+    end
+
+    def qry_fract
+      return 0.0 unless qry_len.zero?
+      @fract ||= len.to_f / qry_len
+    end
+
+    alias fract qry_fract
+
+    def sbj_fract
+      return 0.0 unless sbj_len.zero?
+      @fract ||= len.to_f / sbj_len
+    end
+
+    def to_s
+      row.join("\t")
+    end
+  end
+end

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/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
+