sequence_logo 1.0.3 → 1.0.4

data/lib/sequence_logo/ytilib/hack1.rb

@@ -1,75 +1,75 @@
-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
+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 +1,108 @@
-#!/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
+#!/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

data/lib/sequence_logo/ytilib/iupac.rb

@@ -1,92 +1,92 @@
-class IUPAC < String
-  CODE = {"A" => "A", "C" => "C", "G" => "G", "T" => "T", 
-          "AG" => "R", "CT" => "Y", "GT" => "K", "AC" => "M", 
-          "CG" => "S", "AT" => "W", "CGT" => "B", "AGT" => "D", "ACT" => "H", "ACG" => "V", "ACGT" => "N"}
-  REVCODE = CODE.invert
-  
-  def dup
-    IUPAC.new(self)
-  end
-  
-  def initialize(words)
-    if words.is_a?(Array)
-      iupac = (0...words[0].size).collect { |i|
-        (0...words.size).collect { |j| words[j][i,1] }.uniq.sort.inject("") { |cola, letter| cola += letter }
-      }.inject("") { |iup, cola|
-        checkerr("bad letter set #{cola}") { !CODE.has_key?(cola) }
-        iup += CODE[cola]
-      }
-      super(iupac)
-    elsif words.is_a?(IUPAC)
-      super(words)
-    elsif words.is_a?(String)
-      checkerr("word #{words} has strange characters") { words.tr('ACGTURYKMSWBDHVN', '').size > 0 }
-      super(words)
-    end
-  end
-  
-  def ==(iupac)
-    return false if self.size != iupac.size
-    (0...self.size).inject(true) { |result, i| result &= IUPACOM[self[i,1]][iupac[i,1]] }
-  end
-  
-  def merge(iupac)
-    return nil if self.size != iupac.size
-    res = (0...self.size).inject("") { |res, i|
-      merges = REVCODE[self[i,1]].split(//).concat(REVCODE[iupac[i,1]].split(//)).uniq.sort.inject("") { |s, c| s += c}
-      res << CODE[merges]
-    }
-    return IUPAC.new(res)
-  end
-  
-  def include?(iupac)
-    return false if self.size < iupac.size || !iupac.is_a?(IUPAC)
-    (0..self.size-iupac.size).each { |i|
-      return i if IUPAC.new(self[i,iupac.size]) == iupac
-    }
-    return false
-  end
-  
-  def compl
-    return self.tr("ACGTRYKMSWBDHVN", "TGCAYRMKSWVHDBN")
-  end
-  
-  def compl!
-    self.tr!("ACGTRYKMSWBDHVN", "TGCAYRMKSWVHDBN")
-    return self
-  end
-  
-  alias reverse_string reverse
-  def reverse
-    return IUPAC.new(reverse_string)
-  end
-  
-  alias comp! compl!
-  alias complement! compl!
-  alias comp compl
-  alias complement compl
-  
-private
-  IUPACOM = { "A" => {"A" => :llib, "R" => :llib, "M" => :llib, "W" => :llib, "D" => :llib, "H" => :llib, "V" => :llib, "N" => :llib},
-                "C" => {"C" => :llib, "Y" => :llib, "M" => :llib, "S" => :llib, "B" => :llib, "H" => :llib, "V" => :llib, "N" => :llib},
-                "G" => {"G" => :llib, "R" => :llib, "K" => :llib, "S" => :llib, "B" => :llib, "D" => :llib, "V" => :llib, "N" => :llib},
-                "T" => {"T" => :llib, "Y" => :llib, "K" => :llib, "W" => :llib, "B" => :llib, "D" => :llib, "H" => :llib, "N" => :llib}
-  }
-  IUPACOM["R"] = IUPACOM["G"].merge(IUPACOM["A"])
-  IUPACOM["Y"] = IUPACOM["T"].merge(IUPACOM["C"])
-  IUPACOM["K"] = IUPACOM["G"].merge(IUPACOM["T"])
-  IUPACOM["M"] = IUPACOM["A"].merge(IUPACOM["C"])
-  IUPACOM["S"] = IUPACOM["G"].merge(IUPACOM["C"])
-  IUPACOM["W"] = IUPACOM["A"].merge(IUPACOM["T"])
-  IUPACOM["B"] = IUPACOM["G"].merge(IUPACOM["T"].merge(IUPACOM["C"]))
-  IUPACOM["D"] = IUPACOM["G"].merge(IUPACOM["A"].merge(IUPACOM["T"]))
-  IUPACOM["H"] = IUPACOM["A"].merge(IUPACOM["C"].merge(IUPACOM["T"]))
-  IUPACOM["V"] = IUPACOM["G"].merge(IUPACOM["C"].merge(IUPACOM["A"]))
-  IUPACOM["N"] = IUPACOM["A"].merge(IUPACOM["C"].merge(IUPACOM["G"].merge(IUPACOM["T"])))
- 
-#  IUPACMERGE = CODE.merge({
-#    "AA" => "A", "CC" => "C", "GG" => "G", "TT" => "T",
-#    
-#  })
-
-end
+class IUPAC < String
+  CODE = {"A" => "A", "C" => "C", "G" => "G", "T" => "T", 
+          "AG" => "R", "CT" => "Y", "GT" => "K", "AC" => "M", 
+          "CG" => "S", "AT" => "W", "CGT" => "B", "AGT" => "D", "ACT" => "H", "ACG" => "V", "ACGT" => "N"}
+  REVCODE = CODE.invert
+  
+  def dup
+    IUPAC.new(self)
+  end
+  
+  def initialize(words)
+    if words.is_a?(Array)
+      iupac = (0...words[0].size).collect { |i|
+        (0...words.size).collect { |j| words[j][i,1] }.uniq.sort.inject("") { |cola, letter| cola += letter }
+      }.inject("") { |iup, cola|
+        checkerr("bad letter set #{cola}") { !CODE.has_key?(cola) }
+        iup += CODE[cola]
+      }
+      super(iupac)
+    elsif words.is_a?(IUPAC)
+      super(words)
+    elsif words.is_a?(String)
+      checkerr("word #{words} has strange characters") { words.tr('ACGTURYKMSWBDHVN', '').size > 0 }
+      super(words)
+    end
+  end
+  
+  def ==(iupac)
+    return false if self.size != iupac.size
+    (0...self.size).inject(true) { |result, i| result &= IUPACOM[self[i,1]][iupac[i,1]] }
+  end
+  
+  def merge(iupac)
+    return nil if self.size != iupac.size
+    res = (0...self.size).inject("") { |res, i|
+      merges = REVCODE[self[i,1]].split(//).concat(REVCODE[iupac[i,1]].split(//)).uniq.sort.inject("") { |s, c| s += c}
+      res << CODE[merges]
+    }
+    return IUPAC.new(res)
+  end
+  
+  def include?(iupac)
+    return false if self.size < iupac.size || !iupac.is_a?(IUPAC)
+    (0..self.size-iupac.size).each { |i|
+      return i if IUPAC.new(self[i,iupac.size]) == iupac
+    }
+    return false
+  end
+  
+  def compl
+    return self.tr("ACGTRYKMSWBDHVN", "TGCAYRMKSWVHDBN")
+  end
+  
+  def compl!
+    self.tr!("ACGTRYKMSWBDHVN", "TGCAYRMKSWVHDBN")
+    return self
+  end
+  
+  alias reverse_string reverse
+  def reverse
+    return IUPAC.new(reverse_string)
+  end
+  
+  alias comp! compl!
+  alias complement! compl!
+  alias comp compl
+  alias complement compl
+  
+private
+  IUPACOM = { "A" => {"A" => :llib, "R" => :llib, "M" => :llib, "W" => :llib, "D" => :llib, "H" => :llib, "V" => :llib, "N" => :llib},
+                "C" => {"C" => :llib, "Y" => :llib, "M" => :llib, "S" => :llib, "B" => :llib, "H" => :llib, "V" => :llib, "N" => :llib},
+                "G" => {"G" => :llib, "R" => :llib, "K" => :llib, "S" => :llib, "B" => :llib, "D" => :llib, "V" => :llib, "N" => :llib},
+                "T" => {"T" => :llib, "Y" => :llib, "K" => :llib, "W" => :llib, "B" => :llib, "D" => :llib, "H" => :llib, "N" => :llib}
+  }
+  IUPACOM["R"] = IUPACOM["G"].merge(IUPACOM["A"])
+  IUPACOM["Y"] = IUPACOM["T"].merge(IUPACOM["C"])
+  IUPACOM["K"] = IUPACOM["G"].merge(IUPACOM["T"])
+  IUPACOM["M"] = IUPACOM["A"].merge(IUPACOM["C"])
+  IUPACOM["S"] = IUPACOM["G"].merge(IUPACOM["C"])
+  IUPACOM["W"] = IUPACOM["A"].merge(IUPACOM["T"])
+  IUPACOM["B"] = IUPACOM["G"].merge(IUPACOM["T"].merge(IUPACOM["C"]))
+  IUPACOM["D"] = IUPACOM["G"].merge(IUPACOM["A"].merge(IUPACOM["T"]))
+  IUPACOM["H"] = IUPACOM["A"].merge(IUPACOM["C"].merge(IUPACOM["T"]))
+  IUPACOM["V"] = IUPACOM["G"].merge(IUPACOM["C"].merge(IUPACOM["A"]))
+  IUPACOM["N"] = IUPACOM["A"].merge(IUPACOM["C"].merge(IUPACOM["G"].merge(IUPACOM["T"])))
+ 
+#  IUPACMERGE = CODE.merge({
+#    "AA" => "A", "CC" => "C", "GG" => "G", "TT" => "T",
+#    
+#  })
+
+end