bio 1.3.1 → 1.4.0

data/lib/bio/pathway.rb

@@ -787,174 +787,3 @@ end # Relation
 
 end # Bio
 
-
-
-if __FILE__ == $0
-
-  puts "--- Test === method true/false"
-  r1 = Bio::Relation.new('a', 'b', 1)
-  r2 = Bio::Relation.new('b', 'a', 1)
-  r3 = Bio::Relation.new('b', 'a', 2)
-  r4 = Bio::Relation.new('a', 'b', 1)
-  p r1 === r2
-  p r1 === r3
-  p r1 === r4
-  p [ r1, r2, r3, r4 ].uniq
-  p r1.eql?(r2)
-  p r3.eql?(r2)
-
-  # Sample Graph :
-  #                  +----------------+
-  #                  |                |
-  #                  v                |
-  #       +---------(q)-->(t)------->(y)<----(r)
-  #       |          |     |          ^       |
-  #       v          |     v          |       |
-  #   +--(s)<--+     |    (x)<---+   (u)<-----+
-  #   |        |     |     |     |
-  #   v        |     |     v     |
-  #  (v)----->(w)<---+    (z)----+
-
-  data = [
-    [ 'q', 's', 1, ],
-    [ 'q', 't', 1, ],
-    [ 'q', 'w', 1, ],
-    [ 'r', 'u', 1, ],
-    [ 'r', 'y', 1, ],
-    [ 's', 'v', 1, ],
-    [ 't', 'x', 1, ],
-    [ 't', 'y', 1, ],
-    [ 'u', 'y', 1, ],
-    [ 'v', 'w', 1, ],
-    [ 'w', 's', 1, ],
-    [ 'x', 'z', 1, ],
-    [ 'y', 'q', 1, ],
-    [ 'z', 'x', 1, ],
-  ]
-
-  ary = []
-
-  puts "--- List of relations"
-  data.each do |x|
-    ary << Bio::Relation.new(*x)
-  end
-  p ary
-
-  puts "--- Generate graph from list of relations"
-  graph = Bio::Pathway.new(ary)
-  p graph
-
-  puts "--- Test to_matrix method"
-  p graph.to_matrix
-
-  puts "--- Test dump_matrix method"
-  puts graph.dump_matrix(0)
-
-  puts "--- Test dump_list method"
-  puts graph.dump_list
-
-  puts "--- Labeling some nodes"
-  hash = { 'q' => "L1", 's' => "L2", 'v' => "L3", 'w' => "L4" }
-  graph.label = hash
-  p graph
-
-  puts "--- Extract subgraph by label"
-  p graph.subgraph
-
-  puts "--- Extract subgraph by list"
-  p graph.subgraph(['q', 't', 'x', 'y', 'z'])
-
-  puts "--- Test cliquishness of the node 'q'"
-  p graph.cliquishness('q')
-
-  puts "--- Test cliquishness of the node 'q' (undirected)"
-  u_graph = Bio::Pathway.new(ary, 'undirected')
-  p u_graph.cliquishness('q')
-
-  puts "--- Test small_world histgram"
-  p graph.small_world
-
-  puts "--- Test breadth_first_search method"
-  distance, predecessor = graph.breadth_first_search('q')
-  p distance
-  p predecessor
-
-  puts "--- Test bfs_shortest_path method"
-  step, path = graph.bfs_shortest_path('y', 'w')
-  p step
-  p path
-
-  puts "--- Test depth_first_search method"
-  timestamp, tree, back, cross, forward = graph.depth_first_search
-  p timestamp
-  print "tree edges : "; p tree
-  print "back edges : "; p back
-  print "cross edges : "; p cross
-  print "forward edges : "; p forward
-
-  puts "--- Test dfs_topological_sort method"
-  #
-  # Professor Bumstead topologically sorts his clothing when getting dressed.
-  #
-  #  "undershorts"       "socks"
-  #     |      |            |
-  #     v      |            v           "watch"
-  #  "pants" --+-------> "shoes"
-  #     |
-  #     v
-  #  "belt" <----- "shirt" ----> "tie" ----> "jacket"
-  #     |                                       ^
-  #     `---------------------------------------'
-  #
-  dag = Bio::Pathway.new([
-    Bio::Relation.new("undeershorts", "pants", true),
-    Bio::Relation.new("undeershorts", "shoes", true),
-    Bio::Relation.new("socks", "shoes", true),
-    Bio::Relation.new("watch", "watch", true),
-    Bio::Relation.new("pants", "belt", true),
-    Bio::Relation.new("pants", "shoes", true),
-    Bio::Relation.new("shirt", "belt", true),
-    Bio::Relation.new("shirt", "tie", true),
-    Bio::Relation.new("tie", "jacket", true),
-    Bio::Relation.new("belt", "jacket", true),
-  ])
-  p dag.dfs_topological_sort
-
-  puts "--- Test dijkstra method"
-  distance, predecessor = graph.dijkstra('q')
-  p distance
-  p predecessor
-
-  puts "--- Test dijkstra method by weighted graph"
-  #
-  # 'a' --> 'b'
-  #  |   1   | 3
-  #  |5      v
-  #  `----> 'c'
-  #
-  r1 = Bio::Relation.new('a', 'b', 1)
-  r2 = Bio::Relation.new('a', 'c', 5)
-  r3 = Bio::Relation.new('b', 'c', 3)
-  w_graph = Bio::Pathway.new([r1, r2, r3])
-  p w_graph
-  p w_graph.dijkstra('a')
-
-  puts "--- Test bellman_ford method by negative weighted graph"
-  #
-  # ,-- 'a' --> 'b'
-  # |    |   1   | 3
-  # |    |5      v
-  # |    `----> 'c'
-  # |            ^
-  # |2           | -5
-  # `--> 'd' ----'
-  #
-  r4 = Bio::Relation.new('a', 'd', 2)
-  r5 = Bio::Relation.new('d', 'c', -5)
-  w_graph.append(r4)
-  w_graph.append(r5)
-  p w_graph.bellman_ford('a')
-  p graph.bellman_ford('q')
-
-end
-

data/lib/bio/sequence.rb

@@ -9,7 +9,7 @@
 #               Jan Aerts <jan.aerts@bbsrc.ac.uk>
 # License::     The Ruby License
 #
-# $Id: sequence.rb,v 0.58.2.12 2008/06/17 15:25:22 ngoto Exp $
+# $Id:$
 #
 
 require 'bio/sequence/compat'
@@ -71,6 +71,7 @@ class Sequence
   autoload :Generic, 'bio/sequence/generic'
   autoload :Format,  'bio/sequence/format'
   autoload :Adapter, 'bio/sequence/adapter'
+  autoload :QualityScore, 'bio/sequence/quality_score'
 
   include Format
 
@@ -150,6 +151,22 @@ class Sequence
   # but could be a simple String
   attr_accessor :seq
 
+  # Quality scores of the bases/residues in the sequence.
+  # (Array containing Integer, or nil)
+  attr_accessor :quality_scores
+
+  # The meaning (calculation method) of the quality scores stored in
+  # the <tt>quality_scores</tt> attribute.
+  # Maybe one of :phred, :solexa, or nil.
+  #
+  # Note that if it is nil, and <tt>error_probabilities</tt> is empty,
+  # some methods implicitly assumes that it is :phred (PHRED score).
+  attr_accessor :quality_score_type
+
+  # Error probabilities of the bases/residues in the sequence.
+  # (Array containing Float, or nil)
+  attr_accessor :error_probabilities
+
   #---
   # Attributes below have been added during BioHackathon2008
   #+++

data/lib/bio/sequence/adapter.rb

@@ -23,6 +23,9 @@ module Bio::Sequence::Adapter
   autoload :EMBL,        'bio/db/embl/embl_to_biosequence'
   autoload :FastaFormat, 'bio/db/fasta/fasta_to_biosequence'
   autoload :BioSQL,      'bio/db/biosql/biosql_to_biosequence'
+  autoload :SangerChromatogram,
+           'bio/db/sanger_chromatogram/chromatogram_to_biosequence'
+  autoload :Fastq,       'bio/db/fastq/fastq_to_biosequence'
 
   private
 

data/lib/bio/sequence/format.rb

@@ -47,6 +47,22 @@ module Format
     # (resemble to EMBOSS "ncbi" format)
     autoload :Fasta_ncbi, 'bio/db/fasta/format_fasta'
 
+    # FASTQ "fastq-sanger" format generator
+    autoload :Fastq, 'bio/db/fastq/format_fastq'
+    # FASTQ "fastq-sanger" format generator
+    autoload :Fastq_sanger, 'bio/db/fastq/format_fastq'
+    # FASTQ "fastq-solexa" format generator
+    autoload :Fastq_solexa, 'bio/db/fastq/format_fastq'
+    # FASTQ "fastq-illumina" format generator
+    autoload :Fastq_illumina, 'bio/db/fastq/format_fastq'
+
+    # FastaNumericFormat format generator
+    autoload :Fasta_numeric, 'bio/db/fasta/format_qual'
+    # Qual format generator.
+    # Its format is the same as Fasta_numeric, but it would perform
+    # to convert quality score or generates scores from error probability.
+    autoload :Qual, 'bio/db/fasta/format_qual'
+
   end #module Formatter
 
   # Repository of nucleotide sequence formatter classes

data/lib/bio/sequence/quality_score.rb

@@ -0,0 +1,205 @@
+#
+# = bio/sequence/quality_score.rb - Sequence quality score manipulation modules
+#
+# Copyright::  Copyright (C) 2009
+#              Naohisa Goto <ng@bioruby.org>
+# License::    The Ruby License
+#
+# == Description
+# 
+# Sequence quality score manipulation modules, mainly used by Bio::Fastq
+# and related classes.
+#
+# == References
+#
+# * FASTQ format specification
+#   http://maq.sourceforge.net/fastq.shtml
+#
+
+module Bio
+
+class Sequence
+
+  # Bio::Sequence::QualityScore is a name space for quality score modules. 
+  # BioRuby internal use only (mainly from Bio::Fastq).
+  module QualityScore
+
+    # Converter methods between PHRED and Solexa quality scores.
+    module Converter
+
+      # Converts PHRED scores to Solexa scores.
+      #
+      # The values may be truncated or incorrect if overflows/underflows
+      # occurred during the calculation.
+      # ---
+      # *Arguments*:
+      # * (required) _scores_: (Array containing Integer) quality scores
+      # *Returns*:: (Array containing Integer) quality scores
+      def convert_scores_from_phred_to_solexa(scores)
+        sc = scores.collect do |q|
+          t = 10 ** (q / 10.0) - 1
+          t = Float::MIN if t < Float::MIN
+          r = 10 * Math.log10(t)
+          r.finite? ? r.round : r
+        end
+        sc
+      end
+
+      # Converts Solexa scores to PHRED scores.
+      #
+      # The values may be truncated if overflows/underflows occurred
+      # during the calculation.
+      # ---
+      # *Arguments*:
+      # * (required) _scores_: (Array containing Integer) quality scores
+      # *Returns*:: (Array containing Integer) quality scores
+      def convert_scores_from_solexa_to_phred(scores)
+        sc = scores.collect do |q|
+          r = 10 * Math.log10(10 ** (q / 10.0) + 1)
+          r.finite? ? r.round : r
+        end
+        sc
+      end
+
+      # Does nothing and simply returns the given argument.
+      # 
+      # ---
+      # *Arguments*:
+      # * (required) _scores_: (Array containing Integer) quality scores
+      # *Returns*:: (Array containing Integer) quality scores
+      def convert_nothing(scores)
+        scores
+      end
+
+    end #module Converter
+
+    # Bio::Sequence::QualityScore::Phred is a module having quality calculation
+    # methods for the PHRED quality score.
+    #
+    # BioRuby internal use only (mainly from Bio::Fastq).
+    module Phred
+
+      include Converter
+
+      # Type of quality scores.
+      # ---
+      # *Returns*:: (Symbol) the type of quality score.
+      def quality_score_type
+        :phred
+      end
+
+      # PHRED score to probability conversion.
+      # ---
+      # *Arguments*:
+      # * (required) _scores_: (Array containing Integer) scores
+      # *Returns*:: (Array containing Float) probabilities (0<=p<=1)
+      def phred_q2p(scores)
+        scores.collect do |q|
+          r = 10 ** (- q / 10.0)
+          if r > 1.0 then
+            r = 1.0
+          #elsif r < 0.0 then
+          #  r = 0.0
+          end
+          r
+        end
+      end
+      alias q2p phred_q2p
+      module_function :q2p
+      public :q2p
+
+      # Probability to PHRED score conversion.
+      #
+      # The values may be truncated or incorrect if overflows/underflows
+      # occurred during the calculation.
+      # ---
+      # *Arguments*:
+      # * (required) _probabilities_: (Array containing Float) probabilities
+      # *Returns*:: (Array containing Float) scores
+      def phred_p2q(probabilities)
+        probabilities.collect do |p|
+          p = Float::MIN if p < Float::MIN
+          q = -10 * Math.log10(p)
+          q.finite? ? q.round : q
+        end
+      end
+      alias p2q phred_p2q
+      module_function :p2q
+      public :p2q
+
+      alias convert_scores_from_phred   convert_nothing
+      alias convert_scores_to_phred     convert_nothing
+      alias convert_scores_from_solexa  convert_scores_from_solexa_to_phred 
+      alias convert_scores_to_solexa    convert_scores_from_phred_to_solexa
+      module_function :convert_scores_to_solexa
+      public :convert_scores_to_solexa
+
+    end #module Phred
+
+    # Bio::Sequence::QualityScore::Solexa is a module having quality
+    # calculation methods for the Solexa quality score.
+    #
+    # BioRuby internal use only (mainly from Bio::Fastq).
+    module Solexa
+
+      include Converter
+
+      # Type of quality scores.
+      # ---
+      # *Returns*:: (Symbol) the type of quality score.
+      def quality_score_type
+        :solexa
+      end
+
+      # Solexa score to probability conversion.
+      # ---
+      # *Arguments*:
+      # * (required) _scores_: (Array containing Integer) scores
+      # *Returns*:: (Array containing Float) probabilities
+      def solexa_q2p(scores)
+        scores.collect do |q|
+          t = 10 ** (- q / 10.0)
+          t /= (1.0 + t)
+          if t > 1.0 then
+            t = 1.0
+          #elsif t < 0.0 then
+          #  t = 0.0
+          end
+          t
+        end
+      end
+      alias q2p solexa_q2p
+      module_function :q2p
+      public :q2p
+
+      # Probability to Solexa score conversion.
+      # ---
+      # *Arguments*:
+      # * (required) _probabilities_: (Array containing Float) probabilities
+      # *Returns*:: (Array containing Float) scores
+      def solexa_p2q(probabilities)
+        probabilities.collect do |p|
+          t = p / (1.0 - p)
+          t = Float::MIN if t < Float::MIN
+          q = -10 * Math.log10(t)
+          q.finite? ? q.round : q
+        end
+      end
+      alias p2q solexa_p2q
+      module_function :p2q
+      public :p2q
+
+      alias convert_scores_from_solexa  convert_nothing
+      alias convert_scores_to_solexa    convert_nothing
+      alias convert_scores_from_phred   convert_scores_from_phred_to_solexa
+      alias convert_scores_to_phred     convert_scores_from_solexa_to_phred
+      module_function :convert_scores_to_phred
+      public :convert_scores_to_phred
+
+    end #module Solexa
+
+  end #module QualityScore
+
+end #class Sequence
+
+end #module Bio