sequence_logo 1.0.2

data/lib/sequence_logo/ytilib/pmsd.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/ruby
+module Ytilib
+  class PM
+    def score_sigma(trycount = 4**10, approx = false, bg = nil)
+      
+      scores = []
+      if @size <= 10 && !approx
+        (0...4**@size).each { |i| 
+          word = i.to_s(4).rjust(@size, "0").tr("0123", "ACGT")
+          scores << score(word)
+        }
+      else
+        trycount.times {
+          word = bg ? Randoom.rand_seq(@size, bg) : Randoom.rand_seq(@size)
+          scores << score(word)
+        }
+      end
+      sum1 = scores.inject(0) { |sum,s| sum += s }
+      mean = sum1 / scores.size
+      
+      sum2, sumc = 0, 0
+      scores.each { |score|
+        sum2 += (score-mean)**2
+        sumc += (score-mean)
+      }
+      variance = (sum2 - sumc**2 / scores.size) / (scores.size-1)
+      
+      sigma = Math.sqrt(variance)
+      if block_given?
+        yield(sigma, mean)
+      end
+      
+      return sigma
+    end
+    
+    def fast_score_sigma
+      n, mean, m2 = 0, 0, 0
+      
+      recursive_walk([matrix['A'],matrix['C'],matrix['G'],matrix['T']], 0, 0) { |x|
+        n = n + 1
+        delta = x - mean
+        mean = mean + delta/n
+        m2 = m2 + delta*(x-mean)
+      }
+      
+      variance = m2/(n - 1)
+      
+      if block_given?
+        yield(sigma = Math.sqrt(variance), mean)
+      end
+      
+      return sigma
+    end
+    
+    def fast_score_sigma_precise
+      n, mean = 0, 0
+      
+      recursive_walk([matrix['A'],matrix['C'],matrix['G'],matrix['T']], 0, 0) { |x|
+        n += 1
+        delta = x - mean
+        mean = mean + delta/n
+      }
+      
+      n, m2 = 0, 0
+      recursive_walk([matrix['A'],matrix['C'],matrix['G'],matrix['T']], 0, 0) { |x|
+        n = n + 1
+        delta = x - mean
+        m2 = m2 + delta*(x-mean)
+      }
+      
+      variance = m2/(n - 1)
+      
+      if block_given?
+        yield(sigma = Math.sqrt(variance), mean)
+      end
+      
+      return sigma
+    end
+    
+  private
+    def recursive_walk(matrix, score, i)
+      if i < @size
+        
+        recursive_walk(matrix, score + matrix[0][i], i+1) { |x| yield x }
+        recursive_walk(matrix, score + matrix[1][i], i+1) { |x| yield x }
+        recursive_walk(matrix, score + matrix[2][i], i+1) { |x| yield x }
+        recursive_walk(matrix, score + matrix[3][i], i+1) { |x| yield x }
+        
+      else
+        if block_given?
+          yield(score)
+        else
+          raise "no block for recursive walk"
+        end
+      end
+    end
+  
+  end
+end

data/lib/sequence_logo/ytilib/randoom.rb

@@ -0,0 +1,131 @@
+#!/usr/bin/ruby
+module Ytilib
+
+srand
+
+module Randoom
+  
+  private
+
+  def Randoom.new_counts
+    { 'A' => 0, 'C' => 0, 'G' => 0, 'T' => 0, 'N' => 0 }
+  end
+  
+  def Randoom.random_letter(probs)
+    random = rand()
+    return 'A' if random < probs['A']
+    return 'C' if random < probs['A'] + probs['C']
+    return 'G' if random < probs['A'] + probs['C'] + probs['G']
+    return 'T'
+  end
+
+  public
+  
+  def Randoom.calc_probs(input)
+    counts = new_counts
+    counts.default = 0
+    (0...input.length).each { |i|
+      counts[input[i,1].upcase] += 1
+    }
+    return make_probs!(counts)
+  end
+    
+  def Randoom.rand_seq(req_len, probs = DEF_PROBS, probs_m = nil)
+    randoom = ''
+    if (probs_m == nil)
+      req_len.times { randoom << random_letter(probs) }
+      return randoom  
+    end
+    random_l = random_letter(probs)
+    randoom = random_l
+    (req_len-1).times {
+      cur_probs = probs_m[random_l]
+      random_l = random_letter(cur_probs)
+      randoom << random_l
+    }
+    return randoom
+  end
+  
+  def Randoom.calc_probs_m(input)
+    probs_m = { 'A' => {}, 'C' => {}, 'G' => {}, 'T' => {} }
+    counts = { 'A' => new_counts, 'C' => new_counts, 'G' => new_counts, 'T' => new_counts, 'N' => new_counts }
+    (0...input.length-1).each { |i|
+      pair = input[i, 2].upcase
+      counts[pair[0,1]][pair[1,1]] += 1
+    }
+    probs_m['A'] = make_probs!(counts['A'])
+    probs_m['C'] = make_probs!(counts['C'])
+    probs_m['G'] = make_probs!(counts['G'])
+    probs_m['T'] = make_probs!(counts['T'])
+    return probs_m
+  end
+  
+  def Randoom.make_probs_m!(counts)
+    ['A','C','G','T','N'].each { |l2|
+      addv = counts['N'][l2] / 4.0
+      ['A','C','G','T'].each { |l1|
+        counts[l1][l2] += addv
+      }
+    }
+    
+    probs_m = { 'A' => {}, 'C' => {}, 'G' => {}, 'T' => {} }
+    probs_m['A'] = make_probs!(counts['A'])
+    probs_m['C'] = make_probs!(counts['C'])
+    probs_m['G'] = make_probs!(counts['G'])
+    probs_m['T'] = make_probs!(counts['T'])
+    return probs_m
+  end
+  
+  def Randoom.make_probs!(counts, length = nil)
+    probs = { 'A' => 0, 'C' => 0, 'G' => 0, 'T' => 0 }
+    length = counts['A'] + counts['C'] + counts['G'] + counts['T'] + counts['N'] if length == nil
+    length = length.to_f
+    ['A','C','G','T'].each { |l| counts[l] += counts['N'] / 4.0 }
+    return probs if length == 0
+    probs['A'] = counts['A'] / length
+    probs['C'] = counts['C'] / length
+    probs['G'] = counts['G'] / length
+    probs['T'] = 1 - probs['A'] - probs['C'] - probs['G']
+    return probs
+  end
+  
+  def Randoom.equalize!(probs)
+    probs['A'] = probs['T'] = (probs['A'] + probs['T']) / 2
+    probs['C'] = probs['G'] = (probs['C'] + probs['G']) / 2
+    return probs
+  end
+  
+  def Randoom.twostrand!(probs)
+    return Randoom.equalize!(probs)
+  end
+  
+  DEF_PROBS = PPM.probs2IUPAC!({ 'A' => 0.25, 'C' => 0.25, 'G' => 0.25, 'T' => 0.25, 'N' => 0.25 })
+  
+  # probabilities counted without _random.fa files for human genome
+  DMEL40_PROBS1 = {"A"=>0.287729562173578, "C"=>0.21236364146414, "G"=>0.212259972960341, "T"=>0.287646823401942}
+  DMEL40_PROBS2 = {"A"=>0.28768819278776, "C"=>0.21231180721224, "G"=>0.21231180721224, "T"=>0.28768819278776}
+  
+  DMEL40_PROBS1_M = {"A"=>{"A"=>0.350403075314602, "C"=>0.181194374386404, "G"=>0.188361404205017, "T"=>0.280041146093977}, 
+    "C"=>{"A"=>0.325366772443085, "C"=>0.222264645612127, "G"=>0.197213801868993, "T"=>0.255154780075794}, 
+    "G"=>{"A"=>0.260710563672393, "C"=>0.27150575901391, "G"=>0.222294234776053, "T"=>0.245489442537644}, 
+    "T"=>{"A"=>0.217189093089999, "C"=>0.192590127484359, "G"=>0.239869076706963, "T"=>0.350351702718679}}
+  
+  HG17_PROBS1 = {"A"=>0.295309361730334, "C"=>0.204413561169847, "G"=>0.204519414193999, "T"=>0.295757662905821}
+  HG17_PROBS2 = {"A"=>0.295533512318077, "C"=>0.204466487681923, "G"=>0.204466487681923, "T"=>0.295533512318077}
+  
+  HG17_PROBS1_M = {"A"=>{"A"=>0.331091206257755, "C"=>0.170458424092748, "G"=>0.236770972081246, "T"=>0.261679397568252}, 
+    "C"=>{"A"=>0.354813019140533, "C"=>0.254741288394943, "G"=>0.0481667110625576, "T"=>0.342278981401966}, 
+    "G"=>{"A"=>0.290057117684408, "C"=>0.208514091370804, "G"=>0.254732297362797, "T"=>0.246696493581991}, 
+    "T"=>{"A"=>0.222087715262152, "C"=>0.200697606508443, "G"=>0.245657322003887, "T"=>0.331557356225517}}
+  
+  HG18_PROBS1 = {"A"=>0.291900580635872, "C"=>0.207855064518284, "G"=>0.207968587245859, "T"=>0.292275767599985}
+  HG18_PROBS2 = {"A"=>0.292088174117929, "C"=>0.207911825882071, "G"=>0.207911825882071, "T"=>0.292088174117929}
+  
+  MM9_PROBS1 = {"A"=>0.289755259854654, "C"=>0.210085673636132, "G"=>0.210143929198141, "T"=>0.290015137311074}
+  MM9_PROBS2 = {"A"=>0.289885198582864, "C"=>0.210114801417136, "G"=>0.210114801417136, "T"=>0.289885198582864}
+  
+  MM9_PROBS1_M = {"A"=>{"A"=>0.310389104265713, "C"=>0.184962574392377, "G"=>0.251904718465914, "T"=>0.252743602875996}, "C"=>{"A"=>0.352189584318682, "C"=>0.250794045222924, "G"=>0.0494404816637487, "T"=>0.347575888794645}, "G"=>{"A"=>0.295931117515178, "C"=>0.197870954111653, "G"=>0.250756985626016, "T"=>0.255440942747154}, "T"=>{"A"=>0.219437756702452, "C"=>0.214548041970626, "G"=>0.255405334730743, "T"=>0.310608866596179}}
+
+end
+
+end

data/lib/sequence_logo/ytilib/ytilib.rb

@@ -0,0 +1,147 @@
+module Ytilib
+  def Ytilib.time
+    return Time.now.strftime('%d %b %H:%M:%S')
+  end
+end
+
+$program_name = nil
+
+def start(fullpath)
+  report(fullpath + ARGV.inject("") { |out, v| out += " " + v})
+  return if $NO_REPORT
+  $program_name = "[#{File.name_wo_ext(fullpath)}]"
+end
+
+def report(message, program_name = nil)
+  $program_name = "[#{program_name}]" if program_name != nil
+  return if $NO_REPORT
+  puts "LLIB #{Ytilib.time} #{$program_name}\t#{message}" if !block_given? || yield
+end
+
+def checkerr(message = "checkerr failed")  
+  if !block_given? || yield
+    puts "LLIB #{Ytilib.time} [error]\t#{message}" unless $NO_REPORT
+    raise "LLIB #{Ytilib.time} #{$program_name}\n\t#{message}\n" 
+  end
+end
+
+module Ytilib
+  
+  STRAND_DIRECT = "direct"
+  STRAND_REVCOMP = "revcomp"  
+  
+  def Ytilib.read_mfa2hash(path)
+    input_fasta_f = File.new(path, "r")
+    seqs, seq_name = {}, nil
+    input_fasta_f.each_line { |line|
+      if line[0,1] == ">"
+        seq_name = line[1..-1].strip
+        seq_name = yield seq_name if block_given?
+        checkerr("multiple sequences with the same name=#{seq_name}") { seqs[seq_name] }
+        seqs[seq_name] = ""
+      elsif seq_name != nil
+        seqs[seq_name] << line.strip
+      end
+    }
+    input_fasta_f.close
+    return seqs
+  end
+  
+  def Ytilib.read_mfa2array(path)
+    input_fasta_f = File.new(path, "r")
+    seqs, seq_name = [], nil
+    input_fasta_f.each_line { |line|
+      if line[0,1] == ">"
+        seq_name = line[1..-1].strip
+        yield seq_name if block_given?
+        seqs << ""
+      elsif seq_name != nil
+        seqs.last << line.strip
+      end
+    }
+    input_fasta_f.close
+    return seqs
+  end
+  
+  def Ytilib.mfa2array(input)
+    seqs, seq_name = [], nil
+    input.each_line { |line|
+      if line[0,1] == ">"
+        seq_name = line[1..-1].strip
+        seqs << ""
+      elsif seq_name != nil
+        seqs.last << line.strip
+      end
+    }
+    return seqs
+  end
+  
+  def Ytilib.read_plain2array(path)
+    array = []
+    File.open(path).each_line { |line|
+      array << line.strip if !line.strip.empty?
+    }
+    return array
+  end  
+  
+  def Ytilib.read_seqs2array(path)
+    type = File.ext_wo_name(path)
+    case type
+    when "mfa", "fasta", "fa"
+      return Ytilib.read_mfa2array(path)
+    when "plain","txt"
+      return Ytilib.read_plain2array(path)
+    else
+      checkerr("unknown sequences-file, ext=#{type}")
+    end
+  end
+  
+  def Ytilib.write_mfa(seqs, path, prefix = " ")
+    if seqs.is_a?(Hash)
+      out_fasta_f = File.new(path, "w+")
+      seqs.each_key { |name|
+        out_fasta_f << ">#{prefix}#{name}" << $/ << seqs[name] << $/
+      }
+      out_fasta_f.close
+    else 
+      out_fasta_f = File.new(path, "w+")
+      seqs.each_with_index { |seq, i|
+        out_fasta_f << ">#{prefix}#{i+1}" << $/ << seq << $/
+      }
+      out_fasta_f.close
+    end
+  end
+  
+  def get_consensus(seqs)
+    report "consensus creating method should be checked, you are using unsafe code"
+    return 'nil' if seqs.size == 0
+    conslet = { 'A' => 'A', 'C' => 'C', 'G' => 'G', 'T' => 'T', 'U' => 'U',
+            'AG' => 'R', 'CT' => 'Y', 'GT' => 'K', 'AC' => 'M', 'CG' => 'S', 'AT' => 'W',
+            'CGT' => 'B', 'AGT' => 'D', 'ACT' => 'H', 'ACG' => 'V', 'ACGT' => 'N'
+    }
+    new_consensus, letters = '', []
+    0.upto(seqs[0].size-1) { |i|
+      seqs.each do |word|
+        letters << word[i] if !letters.include?(word[i])
+      end
+      letters.sort!
+      letters_string = ''
+      letters.each do |letter| letters_string << letter end
+      checkerr("cannot find consensus letter for a given letter set :#{}") { conslet[letters_string] == nil }
+      new_consensus << conslet[letters_string]	
+      letters.clear
+    }
+    return new_consensus
+  end
+
+  def Ytilib.new_mysql_conn(database)
+    my = Mysql.new(MYSQL_HOST, MYSQL_USER, MYSQL_PASSWORD, database)
+    checkerr("cannot connect to MySQL server") { my.query("select 1").fetch_row[0] != "1" }
+    return my
+  end  
+  
+
+end
+
+report "ytilib required, working directory #{Dir.pwd}", "ytilib"
+include Ytilib

data/sequence_logo.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/sequence_logo/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Ilya Vorontsov"]
+  gem.email         = ["prijutme4ty@gmail.com"]
+  gem.description   = %q{SequenceLogo is a tool for drawing sequence logos of motifs. It gets Positional Count Matrices(PCMs) or IUPAC sequences as input and generates png-logos for a motif. Also one can create logo for reverse complement or even generate logos for a whole collection of motifs.
+  Sequence logos are a graphical representation of an amino acid or nucleic acid multiple sequence alignment developed by Tom Schneider and Mike Stephens. Each logo consists of stacks of symbols, one stack for each position in the sequence. The overall height of the stack indicates the sequence conservation at that position, while the height of symbols within the stack indicates the relative frequency of each amino or nucleic acid at that position. In general, a sequence logo provides a richer and more precise description of, for example, a binding site, than would a consensus sequence (see http://weblogo.berkeley.edu/)
+}
+  gem.summary       = %q{Tool for drawing sequence logos of motifs}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "sequence_logo"
+  gem.require_paths = ["lib"]
+  gem.version       = SequenceLogo::VERSION
+  
+  gem.add_dependency('rmagick', '~> 2.13.1')
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: sequence_logo
+version: !ruby/object:Gem::Version
+  version: 1.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Ilya Vorontsov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rmagick
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.1
+description: ! "SequenceLogo is a tool for drawing sequence logos of motifs. It gets
+  Positional Count Matrices(PCMs) or IUPAC sequences as input and generates png-logos
+  for a motif. Also one can create logo for reverse complement or even generate logos
+  for a whole collection of motifs.\n  Sequence logos are a graphical representation
+  of an amino acid or nucleic acid multiple sequence alignment developed by Tom Schneider
+  and Mike Stephens. Each logo consists of stacks of symbols, one stack for each position
+  in the sequence. The overall height of the stack indicates the sequence conservation
+  at that position, while the height of symbols within the stack indicates the relative
+  frequency of each amino or nucleic acid at that position. In general, a sequence
+  logo provides a richer and more precise description of, for example, a binding site,
+  than would a consensus sequence (see http://weblogo.berkeley.edu/)\n"
+email:
+- prijutme4ty@gmail.com
+executables:
+- create_all_logos
+- generate_logo
+- pmflogo
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/create_all_logos
+- bin/generate_logo
+- bin/pmflogo
+- lib/sequence_logo.rb
+- lib/sequence_logo/assets/nucl_simpa/a.png
+- lib/sequence_logo/assets/nucl_simpa/c.png
+- lib/sequence_logo/assets/nucl_simpa/g.png
+- lib/sequence_logo/assets/nucl_simpa/t.png
+- lib/sequence_logo/exec/create_all_logos.rb
+- lib/sequence_logo/exec/generate_logo.rb
+- lib/sequence_logo/exec/pmflogo.rb
+- lib/sequence_logo/pmflogo_lib.rb
+- lib/sequence_logo/version.rb
+- lib/sequence_logo/ytilib.rb
+- lib/sequence_logo/ytilib/addon.rb
+- lib/sequence_logo/ytilib/bismark.rb
+- lib/sequence_logo/ytilib/hack1.rb
+- lib/sequence_logo/ytilib/infocod.rb
+- lib/sequence_logo/ytilib/iupac.rb
+- lib/sequence_logo/ytilib/pm.rb
+- lib/sequence_logo/ytilib/pmsd.rb
+- lib/sequence_logo/ytilib/randoom.rb
+- lib/sequence_logo/ytilib/ytilib.rb
+- sequence_logo.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Tool for drawing sequence logos of motifs
+test_files: []