miga-base 1.2.15.1 → 1.2.15.3

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

@@ -1,237 +0,0 @@
-
-##### 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/rand.rb

@@ -1,31 +0,0 @@
-
-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

@@ -1,152 +0,0 @@
-
-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
-

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

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

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

@@ -1,74 +0,0 @@
-
-require 'enveomics_rb/errors'
-require 'zlib'
-
-def use(gems, mandatory = true)
-  gems = [gems] unless gems.is_a? Array
-  begin
-    require 'rubygems'
-    while !gems.empty?
-      require gems.shift
-    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
-
-def say(*msg)
-  $stderr.puts('[%s] %s' % [Time.now, msg.join('')]) unless $QUIET ||= false
-end
-
-def say_inline(*msg)
-  $stderr.print('[%s] %s' % [Time.now, msg.join('')]) unless $QUIET ||= false
-end
-
-##
-# Returns an open reading file handler for the file,
-# supporting .gz and '-' for STDIN
-def reader(file)
-  file == '-' ? $stdin :
-    file =~ /\.gz$/ ? Zlib::GzipReader.open(file) :
-    File.open(file, 'r')
-end
-
-##
-# Returns an open writing file handler for the file,
-# supporting .gz and '-' for STDOUT
-def writer(file)
-  file == '-' ? $stdout :
-    file =~ /\.gz$/ ? Zlib::GzipWriter.open(file) :
-    File.open(file, 'w')
-end
-
-##
-# Run a command +cmd+ that can be a ready-to-go string or an Array to escape
-# 
-# Supported symbol key options in Hash +opts+:
-# - wait: Boolean, should I wait for the command to complete? Default: true
-# - stdout: Path to redirect the standard output
-# - stderr: Path to redirect the standard error
-# - mergeout: Send stderr to stdout
-#
-# Return the process ID. If wait is true (default), check for the exit
-# status and throw an Enveomics::CommandError if non-zero
-def run_cmd(cmd, opts = {})
-  opts[:wait] = true if opts[:wait].nil?
-  cmd = cmd.shelljoin if cmd.is_a? Array
-  cmd += "  > #{opts[:stdout].shellescape}" if opts[:stdout]
-  cmd += " 2> #{opts[:stderr].shellescape}" if opts[:stderr]
-  cmd += ' 2>&1' if opts[:mergeout]
-  pid = spawn(cmd)
-  return pid unless opts[:wait]
-
-  Process.wait(pid)
-  unless $?.success?
-    raise Enveomics::CommandError.new(
-      "Command failed with status #{$?.exitstatus}:\n#{cmd}"
-    )
-  end
-  pid
-end
-

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

@@ -1,135 +0,0 @@
-# @author  Luis M. Rodriguez-R
-# @license Artistic-2.0
-
-##
-# Enveomics representation of a Variant Call Format (VCF) file.
-class VCF
-  
-  ##
-  # File-handler, a File object.
-  attr_reader :fh
-  def initialize(file)
-    @fh = (file.is_a?(String) ? File.open(file, "r") : file )
-  end
-  
-  ##
-  # Iterate through each variant (i.e., each non-comment line), passing a
-  # VCF::Variant object to +blk+.
-  def each_variant(&blk)
-    fh.rewind
-    fh.each_line do |ln|
-      next if ln =~ /^#/
-      blk.call VCF::Variant.new(ln)
-    end
-  end
-
-  ##
-  # Iterate through each header (i.e., each comment line), passing a String to
-  # +blk+.
-  def each_header(&blk)
-    fh.rewind
-    fh.each_line do |ln|
-      next unless ln =~ /^#/
-      blk.call ln
-    end
-  end
-end
-
-class VCF::Variant
-  
-  ##
-  # Column definitions in VCF.
-  @@COLUMNS = [:chrom,:pos,:id,:ref,:alt,:qual,:filter,:info,:format,:bam]
-  
-  ##
-  # An Array of String, containing each of the VCF entrie's columns.
-  attr_reader :data
-
-  ##
-  # Initialize VCF::Variant from String +line+, a non-comment line in the VCF.
-  def initialize(line)
-    @data = line.chomp.split("\t")
-    # Qual as float
-    @data[5] = data[5].to_f
-    # Split info
-    info = data[7].split(";").map{ |i| i=~/=/ ? i.split("=", 2) : [i, true] }
-    @data[7] = Hash[*info.map{ |i| [i[0].to_sym, i[1]] }.flatten]
-    # Read formatted data
-    unless data[9].nil? or data[9].empty?
-      f = format.split(":")
-      b = bam.split(":")
-      f.each_index{ |i| @data[7][f[i].to_sym] = b[i] }
-    end
-    @data[7][:INDEL] = true if ref.size != alt.split(",").first.size
-  end
-
-  ##
-  # Named functions for each column.
-  @@COLUMNS.each_index do |i|
-    define_method(@@COLUMNS[i]) { @@COLUMNS[i]==:pos ? data[i].to_i : data[i] }
-  end
-
-  ##
-  # Sequencing depth.
-  def dp
-    return nil if info[:DP].nil?
-    info[:DP].to_i
-  end
-
-  ##
-  # Sequencing depth of FWD-REF, REV-REF, FWD-ALT, and REV-ALT.
-  def dp4
-    return nil if info[:DP4].nil?
-    @dp4 ||= info[:DP4].split(",").map{ |i| i.to_i }
-    @dp4
-  end
-
-  ##
-  ## Sequencing depth of REF and ALT.
-  def ad
-    return nil if info[:AD].nil?
-    @ad ||= info[:AD].split(",").map{ |i| i.to_i }
-    @ad
-  end
-  
-  ##
-  # Sequencing depth of the REF allele.
-  def ref_dp
-    return dp4[0] + dp4[1] unless dp4.nil?
-    return ad[0] unless ad.nil?
-    nil
-  end
-
-  ##
-  # Sequencing depth of the ALT allele.
-  def alt_dp
-    return dp4[2] + dp4[3] unless dp4.nil?
-    return ad[1] unless ad.nil?
-    nil
-  end
-
-  ##
-  # Information content of the variant in bits (from 0 to 1).
-  def shannon
-    return @shannon unless @shannon.nil?
-    a = ref_dp
-    b = alt_dp
-    ap = a.to_f/(a+b)
-    bp = b.to_f/(a+b)
-    @shannon = -(ap*Math.log(ap,2) + bp*Math.log(bp,2))
-    @shannon
-  end
-
-  ##
-  # Is it an indel?
-  def indel? ; !info[:INDEL].nil? and info[:INDEL] ; end
-
-  ##
-  # Return as String.
-  def to_s ; (data[0..6] + [info_to_s] + data[8..-1].to_a).join("\t") + "\n" ; end
-
-  ##
-  # Returns the INFO entry as String.
-  def info_to_s ; data[7].to_a.map{ |i| i.join("=") }.join(";") ; end
-  
-end