sequence_logo 1.1.2 → 1.2.0

data/lib/sequence_logo/ytilib.rb

@@ -1,10 +0,0 @@
-require_relative 'ytilib/ytilib'
-require_relative 'ytilib/addon'
-require_relative 'ytilib/iupac'
-require_relative 'ytilib/pm'
-require_relative 'ytilib/pmsd'
-require_relative 'ytilib/randoom'
-require_relative 'ytilib/bismark'
-require_relative 'ytilib/hack1'
-require_relative 'ytilib/infocod'
-require_relative 'ytilib/ppm_support'

data/lib/sequence_logo/ytilib/addon.rb

@@ -1,247 +0,0 @@
-#!/usr/bin/ruby
-
-def File.ext_wo_name(what)
-  return what if what.rindex(".") == nil
-  what = File.basename(what)
-  "#{what}"[what.rindex(".")+1..-1]
-end
-
-def File.name_wo_ext(what)
-  return what if what.rindex(".") == nil
-  what = File.basename(what)
-  "#{what}"[0...what.rindex(".")]
-end
-
-class Float
-  def round_to(x)
-    (self * 10**x).round.to_f / 10**x
-  end
-  
-  def cut_to(x)
-    (self.abs * 10**x).floor.to_f * (self == 0.0 ? 0 : self/self.abs).round / 10**x
-  end
-end
-
-class Array
-  def shuffle
-    arr = self.dup
-    arr.size.downto 2 do |j|
-      r = rand j
-      arr[j-1], arr[r] = arr[r], arr[j-1]
-    end
-    arr
-  end
-  
-  def shuffle!
-    (size - 1).downto 1 do |i|
-      j = rand(i + 1)
-      self[i], self[j] = self[j], self[i]
-    end
-    self
-  end
-  
-  def average
-    self.empty? ? nil : self.inject(0) { |sum,s| sum += s } / self.size
-  end
-  alias mean average
-  
-  def variance
-    return self.collect { |s| s*s }.average - average**2
-  end
-  
-  def sum
-    self.inject(self[0]) { |sum,s| sum += s} - self[0]
-  end
-
-end
-
-class String
-  
-  def compl!
-    self.tr!("acgtACGT", "tgcaTGCA")
-    return self
-  end
-  
-  def compl
-    return self.tr("acgtACGT", "tgcaTGCA")
-  end
-  
-  alias comp! compl!
-  alias complement! compl!
-  alias comp compl
-  alias complement compl
-  
-  def revcomp
-    return comp.reverse
-  end
-  
-  def revcomp!
-    return comp!.reverse!
-  end
-  
-  def to_id
-    return self.gsub(/[^.\w]/, '_').upcase
-  end
-  
-end
-
-# Also this can be done is a more sophisticated way
-=begin
-String.class_eval do    
-  def to_id
-    return self.gsub(/[^.\w]/, '_') 
-  end   
-end
-=end
-
-class String
-  # The opposite of String::next / String::succ. It is impossible to be a
-  # *complete* opposite because both "9".next = "10" and "09".next = "10";
-  # if going backwards from "10" there's no way to know whether the result
-  # should be "09" or "9". Where the first ranged character is about to
-  # underflow and the next character is within the same range the result
-  # is shrunk down - that is, "10" goes to "9", "aa" goes to "z"; any non-
-  # range prefix or suffix is OK, e.g. "+!$%10-=+" goes to "+!$%9-=+".
-  # Items in the middle of a string don't do this - e.g. "12.10" goes to
-  # "12.09", to match how "next" would work as best as possible.
-  #
-  # The standard "next" function works on strings that contain *no*
-  # alphanumeric characters, using character codes. This implementation
-  # of "prev" does *not* work on such strings - while strings may contain
-  # any characters you like, only the alphanumeric components are operated
-  # upon.
-  #
-  # Should total underflow result, "nil" will be returned - e.g. "00".prev
-  # returns 'nil', as does "a".prev. This is done even if there are other
-  # characters in the string that were not touched - e.g. "+0.0".prev
-  # also returns "nil". Broadly speaking, a "nil" return value is used for
-  # any attempt to find the previous value of a string that could not have
-  # been generated using "next" in the first place.
-  #
-  # As with "next" sometimes the result of "prev" can be a little obscure
-  # so it is often best to try out things using "irb" if unsure. Note in
-  # particular that software revision numbers do not necessarily behave
-  # predictably, because they don't with "next"! E.g. "12.4.9" might go to
-  # "12.4.10" for a revision number, but "12.4.9".next = "12.5.0". Thus
-  # "12.5.0".prev = "12.4.9" and "12.4.10".prev = "12.4.09" (because the
-  # only way to make "12.4.10" using "next" is to start at "12.4.09").
-  #
-  # Since 'succ' (successor) is an alias for 'next', so 'pred'
-  # (predecessor) is an alias for 'prev'.
-  #
-  def prev(collapse = false)
-    str        = self.dup
-    early_exit = false
-    any_done   = false
-    ranges     = [
-                   ('0'[0]..'9'[0]),
-                   ('a'[0]..'z'[0]),
-                   ('A'[0]..'Z'[0]),
-                   nil
-                 ]
-
-    # Search forward for the first in-range character. If found check
-    # to see if that character is "1", "a" or "A". If it is, record
-    # its index (from 0 to string length - 1). We'll need this if
-    # underflows wrap as far as the found byte because in that case
-    # this first found byte should be deleted ("aa..." -> "z...",
-    # "10..." -> "9...").
-
-    first_ranged = nil
-
-    for index in (1..str.length)
-      byte = str[index - 1]
-
-      # Determine whether or not the current byte is a number, lower case
-      # or upper case letter. We expect 'select' to only find one matching
-      # array entry in 'ranges', thus we dereference index 0 after the
-      # 'end' to put a matching range from within 'ranges' into 'within',
-      # or 'nil' for any unmatched byte.
-
-      within = ranges.select do |range|
-        range.nil? or range.include?(byte)
-      end [0]
-
-      unless within.nil?
-        case within.first
-          when '0'[0]
-            match_byte = '1'[0]
-          else
-            match_byte = within.first
-        end
-
-        first_ranged = index - 1 if (byte == match_byte)
-        first_within = within
-        break
-      end
-    end
-
-    for index in (1..str.length)
-
-      # Process the input string in reverse character order - fetch the
-      # bytes via negative index.
-
-      byte = str[-index]
-
-      within = ranges.select do |range|
-        range.nil? or range.include?(byte)
-      end [0]
-
-      # Skip this letter unless within a known range. Otherwise note that
-      # at least one byte was able to be processed.
-
-      next if within.nil?
-      any_done = true
-
-      # Decrement the current byte. If it is still within its range, set
-      # the byte and bail out - we're finished. Flag the early exit. If
-      # the byte is no longer within range, wrap the character around
-      # and continue the loop to carry the decrement to an earlier byte.
-
-      byte = byte - 1
-
-      if (within.include? byte)
-        str[-index] = byte
-        early_exit  = true
-        break
-      else
-        str[-index] = within.last
-
-        # If we've just wrapped around a character immediately after the
-        # one found right at the start ('0', 'a' or 'A') then this first
-        # ranged character should be deleted (so "10" -> "09"
-
-        if (first_ranged != nil and first_within.include?(byte + 1) and (first_ranged - str.length) == -(index + 1))
-          str.slice!(-(index + 1))
-          early_exit = true
-          break
-        end
-      end
-
-    end # From outer 'for' loop
-
-    # If we did process at least one byte but we did not exit early, then
-    # the loop completed due to carrying a decrement to other bytes. This
-    # means an underflow condition - return 'nil'.
-
-    if (any_done == true and early_exit == false)
-      return nil
-    else
-      return str
-    end
-  end
-
-  # As (extended) String::pred / String::prev, but modifies the string in
-  # place rather than returning a copy. If underflow occurs, the string
-  # will be unchanged. Returns 'self'.
-  #
-  def prev!
-    new_str = prev
-    self.replace(new_str) unless new_str.nil?
-    return self
-  end
-
-  alias pred  prev
-  alias pred! prev!
-
-end

data/lib/sequence_logo/ytilib/bismark.rb

@@ -1,71 +0,0 @@
-#!/usr/bin/ruby
-
-module Ytilib
-require "rexml/document"
-include REXML
-
-class Bismark < Document
-  
-  def initialize(source = nil, add_dtd = false)
-    dtd = add_dtd ? "<!DOCTYPE smallbismark SYSTEM 'smallbismark.dtd'>#{$/}" : ""
-    source == nil ? super("<?xml version='1.0' encoding='UTF-8'?>#{$/}#{dtd}") : super(source)
-    super(IO.read(source)) if source != nil && root == nil
-    if source == nil
-      self.add_element("smallbismark")
-      # xmlns breaks XPath for a REXML library under Linux, strange, indeed
-      # self.add_element("smallbismark", {"xmlns" => "http://bioinform.imb.ac.ru/smallBiSMark/smallbismark.dtd"})
-      self.root.add_element("comment", {"name" => "WARNING"}).add_text("This is a draft version of small-BiSMark. Specification is the subject to change!")
-    end
-  end
-  
-  def getXML
-    beautify
-    s = ""; write(s, 1, true)
-    s.rstrip!
-    return s
-  end
-  alias get_xml getXML
-  
-  def get_pm(xpath)
-    pwmnode = self.elements[xpath]
-    pm = PM.new_pm(pwmnode.attribute("length").value.to_i)
-    toi = pwmnode.name == "PCM"
-    pwmnode.elements.each("pm-column") { |c|
-      position = c.attribute("position").value.to_i - 1
-      weights = [c.elements["a"].get_text.value.strip.to_f, 
-                c.elements["c"].get_text.value.strip.to_f, 
-                c.elements["g"].get_text.value.strip.to_f, 
-                c.elements["t"].get_text.value.strip.to_f]
-      weights.collect { |w| w.to_i } if toi
-      pm['A'][position], pm['C'][position], pm['G'][position], pm['T'][position] = weights[0], weights[1], weights[2], weights[3]
-    }
-    return pm
-  end
-  
-private
-  CONTAIN_NO_TEXT = { 
-                      "segment" => :vasya_shmyak,
-                      "group" => :vasya_shmyak,
-                      "smallbismark" => :vasya_shmyak,
-                      "motif" => :vasya_shmyak,
-                      "PWM" => :vasya_shmyak,
-                      "PCM" => :vasya_shmyak,
-                      "PPM" => :vasya_shmyak,
-                      "source" => :vasya_shmyak,
-                      "factor"  => :vasya_shmyak,
-                      "pm-column" => :vasya_shmyak,
-                      "word-list" => :vasya_shmyak}
-  
-  def beautify(node = self)
-    if node == self 
-      self.delete_if { |e| e.is_a?(Text) }
-      self.each { |e| beautify(e) }
-    else
-      node.delete_if { |e| e.is_a?(Text) } if node.respond_to?(:delete_if) && Bismark::CONTAIN_NO_TEXT.has_key?(node.name)
-      node.each { |e| beautify(e) } if node.respond_to?(:each)
-    end 
-  end
-
-end
-
-end

data/lib/sequence_logo/ytilib/hack1.rb

@@ -1,75 +0,0 @@
-require 'rexml/formatters/pretty'
-
-module REXML
-  module Formatters
-    # The Transitive formatter writes an XML document that parses to an
-    # identical document as the source document.  This means that no extra
-    # whitespace nodes are inserted, and whitespace within text nodes is
-    # preserved.  Within these constraints, the document is pretty-printed,
-    # with whitespace inserted into the metadata to introduce formatting.
-    #
-    # Note that this is only useful if the original XML is not already
-    # formatted.  Since this formatter does not alter whitespace nodes, the
-    # results of formatting already formatted XML will be odd.
-    class Transitive < Default
-      def initialize( indentation=2 )
-        @indentation = indentation
-        @level = 0
-      end
-      
-      protected
-      def write_element( node, output )
-        output << "\n" << ' '*@level
-        output << "<#{node.expanded_name}"
-
-        node.attributes.each_attribute do |attr|
-          output << " "
-          attr.write( output )
-        end unless node.attributes.empty?
-
-        if node.children.empty?
-          output << "/>"
-        else
-          output << ">"
-          # If compact and all children are text, and if the formatted output
-          # is less than the specified width, then try to print everything on
-          # one line
-          skip = false
-          @level += @indentation
-          
-          only_text = true
-          
-          node.children.each { |child|
-          	only_text = child.is_a?(REXML::Text) && only_text
-            write( child, output )
-          }
-          @level -= @indentation
-          output << "#{only_text ? "" : "\n" + ' '*@level}" << "</#{node.expanded_name}>"
-        end
-        
-      end
-
-      def write_text( node, output )
-        output << node.to_s()
-      end
-    end
-  end
-  
-  class Document
-    def write( output=$stdout, indent=-1, trans=false, ie_hack=false )
-      if xml_decl.encoding != "UTF-8" && !output.kind_of?(Output)
-        output = Output.new( output, xml_decl.encoding )
-      end
-      formatter = if indent > -1
-          if trans
-            REXML::Formatters::Transitive.new( indent )
-          else
-            REXML::Formatters::Pretty.new( indent, ie_hack )
-          end
-        else
-          REXML::Formatters::Default.new( ie_hack )
-        end
-      formatter.write( self, output )
-    end
-  end
-end

data/lib/sequence_logo/ytilib/infocod.rb

@@ -1,108 +0,0 @@
-#!/usr/bin/ruby
-
-class Float
-  # Using Stieltjes formula from http://www.luschny.de/math/factorial/approx/SimpleCases.html
-  def log_fact
-    return 0.0 if self <= 1
-    a0 = 1.0/12
-    a1 = 1.0/30 
-    a2 = 53.0/210
-    a3 = 195.0/371
-    a4 = 22999.0/22737
-    a5 = 29944523.0/19733142
-    a6 = 109535241009.0/48264275462
-    z_big = self+1;
-    (1.0/2)*Math.log(2*Math::PI)+(z_big-1.0/2)*Math.log(z_big)-z_big + a0/(z_big+a1/(z_big+a2/(z_big+a3/(z_big+a4/(z_big+a5/(z_big+a6/z_big))))))
-  end
-end
-
-class Integer
-  def log_fact
-    self.to_f.log_fact
-  end
-end
-
-# Naive version
-=begin
-class Integer
-  @@fact_hash = {}
-  def log_fact
-    return 0.0 if self == 0
-    return nil if self < 0
-    if self <= 170
-      @@fact_hash[self] = Math.log( lambda { |k| return k if self.times { |i| k *= i.next } }.call(1) )
-    else
-      return self.to_f.log_fact
-    end unless @@fact_hash.has_key?(self)
-    return @@fact_hash[self] 
-  end
-end
-=end
-
-module Ytilib
-  class PM
-    def infocod(position = nil)
-      return infocod_private(position) if position
-      (0...@size).collect { |i| infocod_private(i) }
-    end
-    alias icd infocod
-    
-    def icd2of4(floor = false)
-      i2o4 = @words_count / 2.0
-      i2o4 = i2o4.floor if floor
-      ([i2o4, i2o4, 0, 0].inject(0.0) { |sum, k_i| sum += k_i.log_fact  } - @words_count.log_fact ) / @words_count
-      # 0 is equal to @words_count % 2, because 0! = 1!
-    end
-    
-    def icd3of4(floor = false)
-      i3o4 = @words_count / 3.0
-      i3o4 = i3o4.floor if floor
-      addon = floor ? @words_count % 3 : 0
-      ([i3o4, i3o4, i3o4, addon].inject(0.0) { |sum, k_i| sum += k_i.log_fact  } - @words_count.log_fact ) / @words_count
-    end
-    
-    def icdThc
-      icd3of4
-    end
-    
-    def icdTlc
-      io = @words_count / 6.0
-      ([2*io, 2*io, io, io].inject(0.0) { |sum, k_i| sum += k_i.log_fact  } - @words_count.log_fact ) / @words_count
-    end
-    
-    def icd4of4(floor = false)
-      i4o4 = @words_count / 4.0
-      i4o4 = i4o4.floor if floor
-      ([i4o4, i4o4, i4o4, i4o4].inject(0.0) { |sum, k_i| sum += k_i.log_fact  } - @words_count.log_fact ) / @words_count
-    end
-    
-  protected
-    def infocod_private(position)
-      k_i = ['A','C','G','T'].collect { |letter| @matrix[letter][position] }  
-      ( k_i.inject(0.0) { |sum, k_i| sum += k_i.log_fact  } - @words_count.log_fact ) / @words_count
-    end
-  end
-  
-  class PPM
-    def to_pcm(words_count = nil)
-      @words_count = words_count if words_count
-      checkerr("words count is not specified") { !@words_count }
-      counts = PM.new_matrix(@size)
-      (0...size).each { |i|
-        ['A', 'C', 'G', 'T'].each { |l|
-          counts[l][i] = @matrix[l][i] * @words_count
-        }
-      }
-      return PM.new(size, counts)
-    end
-    alias to_pcm get_pcm
-    
-    def infocod(position = nil)
-      return to_pcm.infocod(position)
-    end
-    
-    def icd(position = nil)
-      return to_pcm.infocod(position)
-    end
-  end
-end