molecules 0.1.0

data/test/molecules/empirical_formula_test.rb

@@ -0,0 +1,204 @@
+require File.join(File.dirname(__FILE__), '../molecules_test_helper.rb') 
+require 'molecules/empirical_formula'
+
+class EmpiricalFormulaTest < Test::Unit::TestCase
+  include Molecules
+  
+  #
+  # documentation test
+  #
+  
+  def test_documentation
+    assert_equal "Hydrogen", EmpiricalFormula::ELEMENT_INDEX[0].name
+    assert_equal "Oxygen", EmpiricalFormula::ELEMENT_INDEX[1].name
+  
+    water = EmpiricalFormula.new [2,1]
+    assert_equal 'H(2)O', water.to_s
+    assert_equal 18.0105646863, water.mass 
+    
+    alanine = EmpiricalFormula.new [5,1,3,1]
+    assert_equal [3,0,3,1], (alanine - water).formula
+  end
+  
+  #
+  # initialize test
+  #
+  
+  def test_initialize
+    e = EmpiricalFormula.new([])
+    assert_equal([], e.formula)
+
+    e = EmpiricalFormula.new([2,1])
+    assert_equal([2,1], e.formula)
+    
+    e = EmpiricalFormula.new([2,-1])
+    assert_equal([2,-1], e.formula)
+  end
+  
+  def test_intialize_normalizes_formula_by_removing_trailing_zeros
+    zero = EmpiricalFormula.new([0,1,0])
+    assert_equal([0,1], zero.formula)
+  end
+  
+  def test_intialize_normalizes_formula_by_converting_nils_to_zero
+    zero = EmpiricalFormula.new([nil,1,nil,0])
+    assert_equal([0,1], zero.formula)
+  end
+  
+  def test_intialize_freezes_formula
+    formula = [1,2,3]
+    e = EmpiricalFormula.new(formula)
+    
+    assert e.formula.frozen?
+    assert_equal formula.object_id, e.formula.object_id
+  end
+
+  #
+  # + test
+  #
+  
+  def test_PLUS
+    c1 = EmpiricalFormula.new([1, 0, -1])
+    c2 = EmpiricalFormula.new([1, 1, 1])
+    
+    c3 = c1 + c2
+    assert_equal([2,1], c3.formula)
+  end
+  
+  #
+  # - test
+  #
+  
+  def test_MINUS
+    c1 = EmpiricalFormula.new([1, 0, -1])
+    c2 = EmpiricalFormula.new([1, 1, 1])
+    
+    c3 = c1 - c2
+    assert_equal([0, -1, -2], c3.formula)
+  end
+
+  #
+  # * test
+  #
+  
+  def test_MULTIPLY
+    c1 = EmpiricalFormula.new([1, 0, -1])
+    
+    c3 = c1 * 2 * 3
+    assert_equal([6, 0, -6], c3.formula)
+  end
+  
+  #
+  # == test
+  #
+  
+  def test_EQUAL
+    assert EmpiricalFormula.new([1]) == EmpiricalFormula.new([1])
+    assert EmpiricalFormula.new([1]) == EmpiricalFormula.new([1, 0])
+  end
+  
+  #
+  # each test
+  #
+
+  def test_each_returns_elements_and_formula_for_non_zero_formula
+    formula = EmpiricalFormula.new([2,0,1])
+    composition = {}
+    formula.each {|element, factor| composition[element] = factor }
+    
+    assert_equal({EmpiricalFormula::ELEMENT_INDEX[0] => 2, EmpiricalFormula::ELEMENT_INDEX[2] => 1}, composition)
+  end
+  
+  #
+  # to_s test
+  #
+  
+  def test_to_s
+    c1 = EmpiricalFormula.new([2,1])
+    assert_equal "H(2)O", c1.to_s
+    
+    c1 = EmpiricalFormula.new([-2,-1])
+    assert_equal "H(-2)O(-1)", c1.to_s
+  end
+  
+  def test_to_s_symbols_are_sorted_alphabetically
+    c = EmpiricalFormula.new([1, 1, 1])
+    assert_equal "CHO", c.to_s
+  end
+  
+  #
+  # mass test
+  #
+  
+  def test_mass_documentation
+    water = EmpiricalFormula.new [2,1]
+    
+    assert_equal 18.0105646863, water.mass
+    assert_equal 18.0105646863, water.mass {|e| e.mass }
+    
+    assert_equal 18.01528, water.mass {|e| e.std_atomic_weight.value }
+  end
+  
+  def test_mass_returns_monoisotopic_mass_if_no_block_is_given
+    water = EmpiricalFormula.new [2,1]
+    assert_equal 18.0105646863, water.mass
+  end
+  
+  def test_mass_calculates_mass_using_block_result
+    water = EmpiricalFormula.new [2,1]
+    assert_equal 18.01528, water.mass {|e| e.std_atomic_weight.value }
+  end
+  
+  class AltMass 
+    attr_reader :value
+    
+    def initialize(value)
+      @value = value
+    end
+    
+    def +(another)
+      another = another.value if another.kind_of?(AltMass)
+      AltMass.new @value + another
+    end
+    
+    def *(another)
+      another = another.value if another.kind_of?(AltMass)
+      AltMass.new @value * another
+    end
+  end
+  
+  def test_mass_calculation_operates_on_block_result
+    water = EmpiricalFormula.new [2,1]
+    result = water.mass {|e| AltMass.new e.mass }
+    
+    assert result.kind_of?(AltMass)
+    assert_equal 18.0105646863, result.value
+  end
+  
+  #
+  # benchmark
+  #
+
+  def test_operation_speed
+    benchmark_test(20) do |x|
+      n = 10
+      a = EmpiricalFormula.new [1,2,3,4]
+      b = EmpiricalFormula.new [0,-1]
+       
+      x.report("#{n}k +") { (n*1000).times { a + b } }
+      x.report("#{n}k -") { (n*1000).times { a - b } }
+      x.report("#{n}k *") { (n*1000).times { a * 3} }
+    end
+  end
+
+  def test_mass_speed
+    benchmark_test(20) do |x|
+      n = 10
+      a = EmpiricalFormula.new [1,2,3,4]
+      b = EmpiricalFormula.new [0,-1]
+      
+      x.report("#{n}k [1,2,3,4] mass") { (n*1000).times { a.mass {|e| e.mass } } }
+      x.report("#{n}k [0,-1] mass") { (n*1000).times { b.mass {|e| e.mass } } }
+    end
+  end
+end

data/test/molecules/libraries/polypeptide_test.rb

@@ -0,0 +1,128 @@
+require File.join(File.dirname(__FILE__), '../../molecules_test_helper.rb') 
+require 'molecules/libraries/polypeptide'
+
+class PolypeptideTest < Test::Unit::TestCase
+  include Molecules::Libraries
+  
+  #
+  # normalize test
+  #
+
+  def test_normalize_removes_whitespace_and_upcases_sequence
+    assert_equal "ABC", Polypeptide.normalize("Ab\n\rC\t\s")
+  end
+
+  #
+  # initialize test
+  #
+
+  def test_initialize
+    p = Polypeptide.new("")
+    assert_equal "", p.sequence
+    assert_equal([],p.formula)
+    assert_equal({},p.residue_composition)
+    
+    bradykinin = Polypeptide.new("RPPGFSPFR")
+    assert_equal "RPPGFSPFR", bradykinin.sequence
+    assert_equal [71, 10, 50, 15], bradykinin.formula
+    assert_equal({
+      Residue::R => 2, 
+      Residue::P => 3, 
+      Residue::G => 1, 
+      Residue::F => 2, 
+      Residue::S => 1},
+    bradykinin.residue_composition)
+  end
+
+  def test_spaces_are_allowed_in_initialize
+    p = Polypeptide.new("\s\t\r\n")
+    assert_equal "\s\t\r\n", p.sequence
+    assert_equal([],p.formula)
+    assert_equal({},p.residue_composition)
+    
+    bradykinin = Polypeptide.new(" R PP\t\nGFSP\s  FR\r")
+    assert_equal " R PP\t\nGFSP\s  FR\r", bradykinin.sequence
+    assert_equal [71, 10, 50, 15], bradykinin.formula
+    assert_equal({
+      Residue::R => 2, 
+      Residue::P => 3, 
+      Residue::G => 1, 
+      Residue::F => 2, 
+      Residue::S => 1},
+    bradykinin.residue_composition)
+  end
+
+  def test_initialize_raises_error_for_unknown_residues
+    assert_nil Residue['Z']
+    assert_raise(Polypeptide::UnknownResidueError) { Polypeptide.new("Z") }
+  end
+
+  def test_initialize_is_case_sensitive_for_residues
+    assert_not_nil Residue['A']
+    assert_raise(Polypeptide::UnknownResidueError) { Polypeptide.new("a") }
+  end
+
+  #
+  # each_residue test
+  #
+  
+  def test_each_residue_returns_each_residue_sequentially
+    residues = []
+    p = Polypeptide.new("\sRP PG\t F")
+    p.each_residue {|r| residues << r}
+    
+    assert_equal [Residue::R, Residue::P, Residue::P, Residue::G, Residue::F], residues
+  end
+  
+  #
+  # benchmark
+  #
+
+  def test_initialize_speed
+    benchmark_test(20) do |x|
+      n = 10
+
+      x.report("#{n}k RPPGFSPFR") do 
+        (n*1000).times { Polypeptide.new("RPPGFSPFR") }
+      end
+      x.report("#{n}k RPPGFSPFR * 10") do 
+        (n*1000).times { Polypeptide.new("RPPGFSPFR" * 10) }
+      end
+      x.report("#{n*10} RPPGFSPFR * 1000") do 
+        (n*10).times { Polypeptide.new("RPPGFSPFR" * 1000) }
+      end
+    end
+  end
+
+  def test_each_residue_speed
+    benchmark_test(20) do |x|
+      p = Polypeptide.new("RPPGFSPFR" * 10) 
+      
+      x.report("1k RPPGFSPFR * 10") do 
+        1000.times { p.each_residue {|r| r} }
+      end
+      x.report("1k each_byte:") do 
+        1000.times { p.sequence.each_byte {|b| b} }
+      end
+    end
+  end
+  
+  #def test_counting_vs_each_byte
+  #  benchmark_test(20) do |x|
+  #    sequence = "RPPGFSPFR" * 1000
+  #    
+  #    x.report("1k count") do 
+  #      1000.times do 
+  #        Utils.count(sequence, Polypeptide::SEQUENCE_TOKENS)
+  #      end
+  #    end
+  #    
+  #    x.report("1k each_byte") do 
+  #      1000.times do
+  #        array = Array.new(100, 0)
+  #        sequence.each_byte {|b| array[b] += 1}
+  #      end
+  #    end
+  #  end
+  #end
+end

data/test/molecules/libraries/residue_test.rb

@@ -0,0 +1,289 @@
+require File.join(File.dirname(__FILE__), '../../molecules_test_helper.rb') 
+require 'molecules/libraries/residue'
+
+class ResidueTest < Test::Unit::TestCase
+  include Molecules::Libraries
+
+  #
+  # documentation test
+  #
+  
+  def test_documentation
+    r = Residue::A
+    assert_equal "Alanine", r.name
+    assert_equal "Ala", r.abbr
+    assert_equal "A", r.letter
+    assert_equal "CH(3)", r.side_chain.to_s
+  end
+  
+  def test_common_returns_array_of_common_residues
+    assert_equal 20, Residue.common.length
+    assert_equal ['A', 'R', 'N', 'D', 'C', 'E', 'Q', 'G', 'H', 'I', 'L', 'K', 'M', 'F', 'P', 'S', 'T', 'W', 'Y', 'V'].sort, Residue.common.collect {|e| e.letter}.sort
+  end
+  
+  def test_class_lookup
+    a = Residue::A
+  
+    assert_equal a, Residue['A']
+    assert_equal a, Residue['Ala']
+    assert_equal a, Residue['Alanine']
+
+    assert_nil Residue['X']
+    assert_nil Residue['BACKBONE']
+    assert_raise(NoMethodError) { Residue.backbone }
+  end
+  
+  def test_residue_mass_equals_mass_with_parameters
+    ala = Residue::A
+    assert_equal ala.mass, ala.residue_mass
+  end
+  
+  def test_mass_values
+    {
+      'A' => 71.03711,
+      'R' => 156.10111,
+      'N' => 114.04293,
+      'D' => 115.02694,
+      'C' => 103.00919,
+      'E' => 129.04259,
+      'Q' => 128.05858,
+      'G' => 57.02146,
+      'H' => 137.05891,
+      'I' => 113.08406,
+      'L' => 113.08406,
+      'K' => 128.09496,
+      'M' => 131.04049,
+      'O' => 211.14465,
+      'F' => 147.06841,
+      'P' => 97.05276,
+      'S' => 87.03203,
+      'T' => 101.04768,
+      'U' => 150.95363,
+      'W' => 186.07931,
+      'Y' => 163.06333,
+      'V' => 99.06841
+    }.each_pair do |residue, expected|
+      assert_in_delta expected, Residue[residue].mass, delta_mass
+    end
+  end
+    
+  def test_immonium_ion_mass
+    {
+      'A' => 44.05002,
+      'R' => 129.11402,
+      'N' => 87.05584,
+      'D' => 88.03985,
+      'C' => 76.02210,
+      'E' => 102.05550,
+      'Q' => 101.07149,
+      'G' => 30.03437,
+      'H' => 110.07182,
+      'I' => 86.09697,
+      'L' => 86.09697,
+      'K' => 101.10787,
+      'M' => 104.05340,
+      'O' => 184.15756,
+      'F' => 120.08132,
+      'P' => 70.06567,
+      'S' => 60.04494,
+      'T' => 74.06059,
+      'U' => 123.96654,
+      'W' => 159.09222,
+      'Y' => 136.07624,
+      'V' => 72.08132
+    }.each_pair do |residue, expected|
+      assert_in_delta expected, Residue[residue].immonium_ion_mass, delta_mass
+    end
+  end
+
+  # vs the Proteome Commons Residue Reference, 2008-01-11
+  # http://www.proteomecommons.org/archive/1129086318745/docs/residue-reference.html
+  def test_mass_values_vs_proteome_commons
+    str = %Q{
+Alanine A 71.0371137878
+Arginine  R 156.1011110281
+Asparagine  N 114.0429274472
+Aspartic Acid D 115.02694303199999
+Cysteine  C 103.00918447779999
+Glutamic Acid E 129.0425930962
+Glutamine Q 128.05857751140002
+Glycine G 57.0214637236
+Histidine H 137.0589118624
+Isoleucine  I 113.0840639804
+Leucine L 113.0840639804
+Lysine  K 128.0949630177
+Methionine  M 131.0404846062
+Phenylalanine F 147.0684139162
+Proline P 97.052763852
+Serine  S 87.0320284099
+Threonine T 101.0476784741
+Tryptophan  W 186.0793129535
+Tyrosine  Y 163.0633285383
+Valine  V 99.0684139162}
+
+    residues = str.split(/\n/)
+    residues.each do |residue_str|
+      next if residue_str.empty?
+      
+      residue_str =~ /(.*)\s(\w)\s(\d+\.\d+)/
+      name = $1.strip
+      letter = $2
+      mass = $3.to_f
+
+      residue = Residue[letter]
+      assert_not_nil residue, residue_str
+      assert_equal name, residue.name
+      assert_in_delta mass, residue.mass, delta_mass, residue_str 
+    end
+  end
+  
+  # vs the Mascot Amino Acid Reference Data, 2008-01-11
+  # http://hsc-mascot.uchsc.edu/mascot/help/aa_help.html
+  #
+  # minor formatting was done on this table to make it nice for the test;
+  # the formatting consisted of condensing residue names and formula
+  # to the same line and moving composites to a separate string. ex:
+  #   Alanine
+  #   C3H5NO  Ala   A   71.03712  71.08   Ala
+  # became
+  #   Alanine C3H5NO  Ala   A   71.03712  71.08   Ala
+  #
+  # Note there are minor capitalization differences in the names and 
+  # abbreviations relative to those in Residue
+  def test_mass_values_vs_mascot
+    str = %Q{
+Alanine C3H5NO  Ala   A   71.03712  71.08   Ala
+Arginine C6H12N4O   Arg   R   156.10112   156.19  Arg
+Asparagine C4H6N2O2   Asn   N   114.04293   114.10  Asn
+Aspartic acid C4H5NO3   Asp   D   115.02695   115.09  Asp
+Cysteine C3H5NOS  Cys   C   103.00919   103.14  Cys
+Glutamic acid C5H7NO3   Glu   E   129.04260   129.12  Glu
+Glutamine C5H8N2O2  Gln   Q   128.05858   128.13  Gln
+Glycine C2H3NO  Gly   G   57.02147  57.05   Gly
+Histidine C6H7N3O   His   H   137.05891   137.14  His
+Isoleucine C6H11NO  Ile   I   113.08407   113.16  Ile
+Leucine C6H11NO   Leu   L   113.08407   113.16  Leu
+Lysine C6H12N2O   Lys   K   128.09497   128.17  Lys
+Methionine C5H9NOS  Met   M   131.04049   131.19  Met
+Phenylalanine C9H9NO  Phe   F   147.06842   147.18  Phe
+Proline C5H7NO  Pro   P   97.05277  97.12   Pro
+Serine C3H5NO2  Ser   S   87.03203  87.08   Ser
+Threonine C4H7NO2   Thr   T   101.04768   101.10  Thr
+Selenocysteine C3H5NOSe   SeC   U   150.95364   150.03  SeC
+Tryptophan C11H10N2O  Trp   W   186.07932   186.21  Trp
+Tyrosine C9H9NO2  Tyr   Y   163.06333   163.18  Tyr
+Valine C5H9NO   Val   V   99.06842  99.13   Val}
+
+    composites = %Q{
+Asn or Asp  Asx   B      
+Glu or Gln  Glx   Z 
+Unknown   Xaa   X}
+
+    residues = str.split(/\n/)
+    residues.each do |residue_str|
+      next if residue_str.empty?
+      
+      residue_str =~ /(.*)\s+([\w\d]+)\s+(\w\w\w)\s+(\w)\s+(\d+\.\d+)\s+(\d+\.\d+)\s+\w\w\w/
+      name = $1
+      formula = $2
+      abbr = $3
+      letter = $4
+      monoisotopic = $5.to_f
+      average = $6.to_f
+
+      residue = Residue[letter]
+      assert_not_nil residue, residue_str
+      assert_equal name.upcase, residue.name.upcase, residue_str
+      assert_equal abbr.upcase, residue.abbr.upcase, residue_str
+      assert_equal formula, residue.to_s.gsub(/\(|\)/, ""), residue_str
+      
+      assert_in_delta monoisotopic, residue.mass, delta_mass, residue_str 
+      # TODO -- check average mass
+    end
+  end
+  
+  # vs the VG Analytical Organic Mass Spectrometry reference, reference date unknown (prior to 2005)
+  # the data from the data sheet was copied manually to doc/VG Analytical DataSheet.txt
+  def test_mass_values_vs_vg_analytical
+    common = %Q{
+Ala A Alanine C3H5NO 71.03711 71.0788
+Arg R Arginine C6H12N4O 156.10111 156.1875
+Asn N Asparagine C4H6N2O2 114.04293 114.1038
+Asp D Aspartic Acid C4H5NO3 115.02694 115.0886
+Cys C Cysteine C3H5NOS 103.00919 103.1388
+Glu E Glutamic Acid C5H7NO3 129.04259 129.115
+Gln Q Glutamine C5H8N2O2 128.05858 128.1307
+Gly G Glycine C2H3NO 57.02146 57.0519
+His H Histidine C6H7N3O 137.05891 137.1411
+Ile I Isoleucine C6H11NO 113.08406 113.1594
+Leu L Leucine C6H11NO 113.08406 113.1594
+Lys K Lysine C6H12N2O 128.09496 128.1741
+Met M Methionine C5H9NOS 131.04049 131.1926
+Phe F Phenylalanine C9H9NO 147.06841 147.1766
+Pro P Proline C5H7NO 97.05276 97.1167
+Ser S Serine C3H5NO2 87.03203 87.0782
+Thr T Threonine C4H7NO2 101.04768 101.1051
+Trp W Tryptophan C11H10N2O 186.07931 186.2132
+Tyr Y Tyrosine C9H9NO2 163.06333 163.1760
+Val V Valine C5H9NO 99.06841 99.1326}
+
+    residues = common.split(/\n/)
+    residues.each do |residue_str|
+      next if residue_str.empty?
+      
+      residue_str =~ /(\w\w\w) (\w) (\w+( Acid)?) ([\w\d]+) (\d+\.\d+) (\d+\.\d+)/
+      abbr = $1
+      letter = $2
+      name = $3
+      formula = $5
+      monoisotopic = $6.to_f
+      average = $7.to_f
+
+      residue = Residue[letter]
+      assert_not_nil residue, residue_str
+      assert_equal name, residue.name, residue_str
+      assert_equal abbr, residue.abbr, residue_str
+      assert_equal formula, residue.to_s.gsub(/\(|\)/, ""), residue_str
+      
+      assert_in_delta monoisotopic, residue.mass, delta_mass, residue_str 
+      # TODO -- check average mass
+    end
+    
+    uncommon = %Q{
+Orn Ornithine C5H10N2O 114.07931 114.1472
+Aba Aminobutyric Acid C4H7NO 85.05276 85.1057
+AECys Aminoethylcysteine C5H10N2OS 146.05138 146.2072
+Aib alpha-Aminoisobutyric Acid C4H7NO 85.05276 85.1057
+CMCys Carboxymethylcysteine C5H7NO3S 161.01466 161.1755
+Dha Dehydroalanine C3H3NO 69.02146 69.0629
+Dhb Dehydroamino-alpha-butyric Acid C4H5NO 83.03711 83.0898
+Hyl Hydroxylysine C6H12N2O2 144.08988 144.1735
+Hyp Hydroxyproline C5H7NO2 113.04768 113.1161
+Iva Isovaline C5H9NO 99.06841 99.1326
+nLeu Norleucine C6H11NO 113.08406 113.1594
+Pip 2-Piperidinecarboxylic Acid C6H9NO 111.06841 111.1436
+pGlu Pyroglutamic Acid C5H5NO2 111.03203 111.1002
+Sar Sarcosine C3H5NO 71.03711 71.0788}
+
+    residues = uncommon.split(/\n/)
+    residues.each do |residue_str|
+      next if residue_str.empty?
+      
+      residue_str =~ /(\w+) ([\w-]+( Acid)?) ([\w\d]+) (\d+\.\d+) (\d+\.\d+)/
+      abbr = $1
+      name = $2
+      formula = $4
+      monoisotopic = $5.to_f
+      average = $6.to_f
+      
+      residue = Residue[abbr]
+      assert_not_nil residue, residue_str
+      assert_equal name, residue.name, residue_str
+      assert_equal formula, residue.to_s.gsub(/\(|\)/, ""), residue_str
+      
+      assert_in_delta monoisotopic, residue.mass, delta_mass, residue_str 
+      # TODO -- check average mass
+    end
+  end
+  
+end