bahuvrihi-molecules 0.1.2 → 0.2.0

data/MIT-LICENSE

@@ -1,6 +1,4 @@
 Copyright (c) 2006-2008, Regents of the University of Colorado.
-Developer:: Simon Chiang, Biomolecular Structure Program
-Support:: CU Denver School of Medicine Deans Academic Enrichment Fund
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this
 software and associated documentation files (the "Software"), to deal in the Software

data/README

@@ -47,8 +47,8 @@ Molecules provides a mass calculator tap task.  Tap[http://tap.rubyforge.org]
 is not required by molecules in general, but you get this bonus if you have tap
 installed:
 
-  % tap -- molecules/calc ":RPPGFSPFR + H2O"
-    I[15:34:30]         1077.57 Da :RPPGFSPFR + H2O
+  % tap run -- molecules/calc H2O
+    I[17:08:00]   18.0105646863 Da H2O
 
 == Known Issues
 

data/lib/molecules/calc.rb

@@ -1,4 +1,5 @@
-require 'molecules/empirical_formula'
+require 'tap/task'
+require 'molecules/empirical_formula'
 require 'molecules/libraries/polypeptide'
 
 # patch for ruby units
@@ -7,29 +8,37 @@ class Unit < Numeric # :nodoc:
   UNIT_DEFINITIONS['<dalton>'] = [%w{Da Dalton Daltons dalton daltons}, 1/6.0221415e26, :mass, %w{<kilogram>}]
 end
 Unit.setup
-
-module Molecules
-
-  # :startdoc::manifest a mass calculator
-  #
-  # Calculates the mass of a molecule.  Compound formulae are allowed and you may
-  # specify a list of formulae. The options can be used to alter the output (precision, 
-  # mass calculation method etc.)
-  #
-  #   % tap run -- molecules/calc H2O
-  #     I[17:08:00]   18.0105646863 Da H2O
+
+module Molecules
+
+  # :startdoc::task a mass calculator
+  #
+  # Calculates the mass of a molecule or formula. The options can be used to
+  # alter the output (precision,  mass calculation method etc.)
+  #
+  #   % tap run -- molecules/calc H2O --: dump
+  #   18.0106 Da
+  #   
+  #   % tap run -- molecules/calc "NH3 + H2O" --precision 2 --: dump
+  #   35.04 Da
+  #
+  # Units can carry prefixes (ex 'mm', 'kg').  See {Ruby Units}[http://ruby-units.rubyforge.org/ruby-units/]
+  # for more information.
+  #
+  #   % tap run -- molecules/calc H2O --units yg --precision 2 --: dump
+  #   29.91 yg
   #
-  #   % tap run -- molecules/calc H2O --units yg --precision 6
-  #     I[17:08:21]       29.907243 yg H2O
-  #
-  #   % tap run -- molecules/calc 'C3H5NO + H2O' C50H73N15O11 -p 2
-  #     I[17:08:53]           89.05 Da C3H5NO + H2O
-  #     I[17:08:53]         1059.56 Da C50H73N15O11
-  #
-  class Calc < Tap::Task
-  
-    config :type, :monoisotopic                             # the mass type calculated
-    config :precision, nil, :short => 'p'                   # the precision of the mass
+  # Note that Calc returns instances of Unit, which by default prints itself
+  # with a precison of 4.  To view the full-precision value, inspect the scalar
+  # value of the result.
+  #
+  #   % tap run -- molecules/calc H2O --: inspect -m scalar
+  #   18.0105646863
+  #
+  class Calc < Tap::Task
+  
+    config :type, :monoisotopic                             # the mass type calculated
+    config :precision, nil, :short => 'p'                   # the precision of the mass
     config :units, "Da", :short => 'u', &c.string           # the mass unit reported
     config :composition, false, :short => 'c', &c.flag      # reports the composition, not the formula
     
@@ -40,27 +49,23 @@ module Molecules
       EmpiricalFormula.parse(formula)
     end
     
-    # Returns an array of the calculated masses, in the correct unit.
-    def process(*formulae)
-      formulae.collect do |formula_str|
-        mass = parse(formula_str).mass do |element|
-          case type
-          when :monoisotopic then element.mass
-          when :average then element.std_atomic_weight.value
-          else raise "unknown mass type: #{type}"
-          end
+    # Returns an array of the calculated masses, in the correct unit.
+    def process(formula)
+      mass = parse(formula).mass do |element|
+        case type
+        when :monoisotopic then element.mass
+        when :average then element.std_atomic_weight.value
+        else raise "unknown mass type: #{type}"
         end
+      end
 
-        mass = Unit.new(mass, "Da").convert_to(units)
-        unless precision == nil
-          mass = Unit.new( Utils.round(mass.scalar, precision), units) 
-        end
-
-        log "#{mass.scalar} #{mass.units}", composition ? formula : formula_str
-
-        mass
-      end
+      mass = Unit.new(mass, "Da").convert_to(units)
+      unless precision == nil
+        mass = Unit.new( Utils.round(mass.scalar, precision), units) 
+      end
+
+      mass
     end
-    
-  end
+    
+  end
 end

data/lib/molecules/empirical_formula.rb

@@ -299,7 +299,7 @@ module Molecules
     # - Masses are calculated such that mathematical operations 
     #   are performed on the return of the block.
     # 
-    def mass(&block)
+    def mass(&block) # :yields: element
       if block_given? 
         mass = 0
         each {|e, n| mass = (yield(e) * n) + mass }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bahuvrihi-molecules
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors: 
 - Simon Chiang
@@ -9,11 +9,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-13 00:00:00 -07:00
+date: 2009-04-08 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: constants
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -21,6 +22,16 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 0.1.0
     version: 
+- !ruby/object:Gem::Dependency 
+  name: tap
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.17.0
+    version: 
 description: 
 email: simon.a.chiang@gmail.com
 executables: []
@@ -31,9 +42,6 @@ extra_rdoc_files:
 - README
 - MIT-LICENSE
 files: 
-- MIT-LICENSE
-- Rakefile
-- README
 - lib/molecules.rb
 - lib/molecules/calc.rb
 - lib/molecules/empirical_formula.rb
@@ -41,16 +49,8 @@ files:
 - lib/molecules/libraries/residue.rb
 - lib/molecules/utils.rb
 - tap.yml
-- test/molecules/calc_test.rb
-- test/molecules/empirical_formula_class_test.rb
-- test/molecules/empirical_formula_test.rb
-- test/molecules/libraries/polypeptide_test.rb
-- test/molecules/libraries/residue_test.rb
-- test/molecules/utils_test.rb
-- test/molecules_test.rb
-- test/molecules_test_helper.rb
-- test/molecules_test_suite.rb
-- test/tap_test_helper.rb
+- README
+- MIT-LICENSE
 has_rdoc: true
 homepage: http://bioactive.rubyforge.org/molecules/
 post_install_message: 
@@ -77,5 +77,5 @@ rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: A library of molecules for scientific calculations in Ruby.
-test_files: 
-- test/molecules_test_suite.rb
+test_files: []
+

data/Rakefile

@@ -1,79 +0,0 @@
-require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-require 'rake/gempackagetask'
-require 'yaml'
-
-# tasks
-desc 'Default: Run tests.'
-task :default => :test
-
-desc 'Run tests.'
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.pattern = File.join('test', ENV['subset'] || '', ENV['pattern'] || '**/*_test.rb')
-  t.verbose = true
-  t.warning = true
-end
-
-#
-# admin tasks
-#
-
-def gemspec
-  data = File.read("molecules.gemspec")
-  spec = nil
-  Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
-  spec
-end
-
-Rake::GemPackageTask.new(gemspec) do |pkg|
-  pkg.need_tar = true
-end
-
-task :print_manifest do
-  # collect files from the gemspec, labeling 
-  # with true or false corresponding to the
-  # file existing or not
-  files = gemspec.files.inject({}) do |files, file|
-    files[File.expand_path(file)] = [File.exists?(file), file]
-    files
-  end
-  
-  # gather non-rdoc/pkg files for the project
-  # and add to the files list if they are not
-  # included already (marking by the absence
-  # of a label)
-  Dir.glob("**/*").each do |file|
-    next if file =~ /^(rdoc|pkg)/ || File.directory?(file)
-    
-    path = File.expand_path(file)
-    files[path] = ["", file] unless files.has_key?(path)
-  end
-  
-  # sort and output the results
-  files.values.sort_by {|exists, file| file }.each do |entry| 
-    puts "%-5s : %s" % entry
-  end
-end
-
-desc 'Generate documentation.'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = "molecules"
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include(["README", 'MIT-LICENSE'])
-  rdoc.rdoc_files.include(gemspec.files.select {|file| file =~ /^lib/})
-end
-
-desc "Publish RDoc to RubyForge"
-task :publish_rdoc => [:rdoc] do
-  config = YAML.load(File.read(File.expand_path("~/.rubyforge/user-config.yml")))
-  host = "#{config["username"]}@rubyforge.org"
-  
-  rsync_args = "-v -c -r"
-  remote_dir = "/var/www/gforge-projects/bioactive/molecules"
-  local_dir = "rdoc"
- 
-  sh %{rsync #{rsync_args} #{local_dir}/ #{host}:#{remote_dir}}
-end

data/test/molecules/calc_test.rb

@@ -1,37 +0,0 @@
-require File.join(File.dirname(__FILE__), '../tap_test_helper.rb') 
-require 'molecules/calc'
-
-class Molecules::CalcTest < Test::Unit::TestCase
-  acts_as_tap_test 
-  
-  attr_reader :t
-  
-  def setup
-    super
-    @t = Molecules::Calc.new
-  end
-  
-  def test_mass_calculation
-    t.enq("H2O")
-    app.run
-      
-    assert_equal [[Unit.new(18.0105646863, "Da")]], app.results(t)
-  end
-  
-  def test_mass_calculation_with_precision
-    t.precision = 2
-    t.enq("H2O", "NH3 + H2O")
-    app.run
-      
-    assert_equal [[Unit.new(18.01, "Da"), Unit.new(35.04, "Da")]], app.results(t)
-  end
-  
-  def test_mass_calculation_with_precision_and_unit_conversion
-    t.units = "yg"
-    t.precision = 3
-    t.enq("H2O")
-    app.run
-      
-    assert_equal [[Unit.new(29.907, "yg")]], app.results(t)
-  end
-end

data/test/molecules/empirical_formula_class_test.rb

@@ -1,196 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../molecules_test_helper.rb')) 
-require 'molecules/empirical_formula'
-
-class EmpiricalFormulaClassTest < Test::Unit::TestCase
-  include Molecules
-  
-  #
-  # parse_simple test
-  #
-  
-  def test_parse_simple_documentation
-    assert_equal "H(2)O", EmpiricalFormula.parse_simple("H(2)O").to_s
-    assert_equal "H(2)O", EmpiricalFormula.parse_simple("H (2) O").to_s
-    assert_equal "H(2)O", EmpiricalFormula.parse_simple("HO(-1)O(2)H").to_s
-  end
-  
-  def test_parse_simple
-    assert_equal([2,1], EmpiricalFormula.parse_simple("HO(-1)O(2)H").formula)
-    assert_equal([2,1], EmpiricalFormula.parse_simple("H O (-1  )O( 2) H ").formula)
-  end
-  
-  def test_parse_simple_fails_for_malformed_formulae
-    [
-      # numbers outside parenthesis
-      "H2", 
-      # empty parenthesis
-      "H()",
-      # mismatched parenthesis
-      "H(",
-      ")H",
-      # anything complex
-      "H + O"
-    ].each do |formula|
-      assert_raise(EmpiricalFormula::ParseError) { EmpiricalFormula.parse_simple(formula) }
-    end
-  end
-  
-  #
-  # test class parse
-  #
-  
-  def test_parse_documentation
-    assert_equal "H(2)O", EmpiricalFormula.parse("H2O").to_s
-    assert_equal "C(52)H(106)", EmpiricalFormula.parse("CH3(CH2)50CH3").to_s 
-    assert_equal "C(2)H(4)N(2)", EmpiricalFormula.parse("C2H3NO - H2O + NH3").to_s 
-    
-    block = lambda do |formula|
-      case formula
-      when /\[(.*)\]/
-        factors = $1.split(/,/).collect {|i| i.strip.to_i }
-        EmpiricalFormula.new(factors)
-      else nil
-      end
-    end
-    
-    assert_equal  "H(4)O(2)", EmpiricalFormula.parse("H2O + [2, 1]", &block).to_s
-    assert_raise(EmpiricalFormula::ParseError) { EmpiricalFormula.parse("H2O + :not_expected", &block) }
-  end
-  
-  def test_parse
-    {
-      nil => "",
-      "" => "",
-      "H" => "H", 
-      "HO" => "HO", 
-      "HFe" => "FeH", 
-      "FeH" => "FeH", 
-      "OH2" => "H(2)O",
-      "H2O" => "H(2)O", 
-      "C6H12O4" => "C(6)H(12)O(4)", 
-      "Fe2OMg3" => "Fe(2)Mg(3)O", 
-      "(H)2" => "H(2)", 
-      "(OH)2" => "H(2)O(2)", 
-      "(HFe)" => "FeH", 
-      "(FeH)" => "FeH", 
-      "(OH2)2" => "H(4)O(2)", 
-      "(H2O)2" => "H(4)O(2)", 
-      "(C6H12O4)2" => "C(12)H(24)O(8)",
-      "(Fe2OMg3)2" => "Fe(4)Mg(6)O(2)",
-      "C6H12O4(C6H12O4)2C6H12O4" => "C(24)H(48)O(16)", 
-      "Fe2OMg3(Fe2OMg3(Fe2OMg3))Fe2OMg3" => "Fe(8)Mg(12)O(4)",
-      "Fe2OMg3(Fe2OMg3)(Fe2OMg3)Fe2OMg3" => "Fe(8)Mg(12)O(4)",
-      "Fe2OMg3(Fe2OMg3(Fe2OMg3)3((C)6H12O4)2)2C" => "C(25)Fe(18)H(48)Mg(27)O(25)",
-      "  (H2O) 10 0   " => "H(200)O(100)",
-      "CH3(CH2)7CH" => "C(9)H(18)", 
-      "H3NCHCO2" => "C(2)H(4)NO(2)", 
-      "(CH3)2CuLi" => "C(2)CuH(6)Li",
-      
-      # multipart
-      "-H" => "H(-1)",
-      "H2O-H" => "HO",
-      "H2O - (OH)2+ H2O2-H2O" => ""
-    }.each_pair do |formula, composition_str|
-      m = EmpiricalFormula.parse(formula)
-      assert_equal composition_str, m.to_s, formula
-    end
-  end
-  
-  def test_parse_fails_for_malformed_formulae
-    [
-      # mismatched parenthesis
-      "H)2",
-      "(H2", 
-      "(O2(H2)",
-      "(O)2H2)", 
-      # hanging factors
-      "2C", 
-      #"(2)",
-      "(2)2", 
-      "(2C)", 
-      "(2C)2",
-      "C(2C)",
-      # empty parenthesis
-      "()",
-      "()2"
-    ].each do |formula|
-      assert_raise(EmpiricalFormula::ParseError) { EmpiricalFormula.parse(formula) }
-    end
-  end
-  
-  #
-  # class mass test
-  #
-  
-  def break_test_class_mass_method
-    water_mass = EmpiricalFormula::Element::H.mass * 2 + EmpiricalFormula::Element::O.mass
-    assert_equal 18.010565, water_mass
-    
-    assert_equal 18.010565, EmpiricalFormula.mass("H2O")
-    assert_equal 18.010565, EmpiricalFormula.mass("H + OH")
-    assert_equal 18, EmpiricalFormula.mass("H2O", 0)
-  end
-  
-  #
-  # library molecules
-  #
-  
-  def break_test_access_library_molecules
-    water = EmpiricalFormula::H2O
-    
-    assert_equal water, EmpiricalFormula.lookup('h2o')
-    assert_equal water, EmpiricalFormula.h2o
-    assert_equal 18.010565, EmpiricalFormula.h2o.mass
-  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_molecule_mass_values_vs_vg_analytical
-    str = %Q{
-NH2 16.01872 16.0226
-OH 17.00274 17.0073
-OCH3 31.01839 31.0342
-CH3CO 43.01839 43.0452}
-
-    molecules = str.split(/\n/)
-    molecules.each do |mol_str|
-      next if mol_str.empty?
-      
-      name, monoisotopic, average = mol_str.split(/\s/)
-      monoisotopic = monoisotopic.to_f
-      average = average.to_f
-      
-      molecule = EmpiricalFormula.parse(name)
-      assert_in_delta monoisotopic, molecule.mass, delta_mass, mol_str 
-      # TODO -- check average mass
-    end    
-  end
-
-  #
-  # benchmark
-  #
-   
-  def test_parse_speed
-    benchmark_test(20) do |x|
-      n = 10
-       
-      ["H20","H2(H2(H2))H2"].each do |formula|
-        x.report("#{n}k #{formula}") do 
-          (n*1000).times { EmpiricalFormula.parse(formula) }
-        end
-      end
-    end
-  end
-   
-  def test_parse_simple_speed
-    benchmark_test(20) do |x|
-      n = 10
-       
-      ["H(20)","H(2)H(2)H(2)H(2)"].each do |formula|
-        x.report("#{n}k #{formula}") do 
-          (n*1000).times { EmpiricalFormula.parse_simple(formula) }
-        end
-      end
-    end
-  end
-end

data/test/molecules/empirical_formula_test.rb

@@ -1,204 +0,0 @@
-require File.expand_path(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

@@ -1,128 +0,0 @@
-require File.expand_path( 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

@@ -1,289 +0,0 @@
-require File.expand_path( 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

data/test/molecules/utils_test.rb

@@ -1,147 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../molecules_test_helper.rb')) 
-require 'molecules/utils'
-
-class UtilsTest < Test::Unit::TestCase
-  include Molecules::Utils
-  
-  #
-  # round test
-  #
-  
-  def test_round
-    assert_equal 0, round(0.20, 0)
-    assert_equal 0.2, round(0.20, 1)
-    assert_equal 0.2, round(0.20, 2)
-    assert_equal 0.2, round(0.20, 3)
-     
-    assert_equal 0.2, round(0.18, 1)
-    assert_equal 0.2, round(0.15, 1)
-    assert_equal 0.1, round(0.13, 1)
-    assert_equal 0.13, round(0.13, 3)
-    
-    assert_equal 10, round(13, -1)
-    assert_equal 0, round(13, -2)
-  end
-  
-  #
-  # add
-  #
-  
-  def test_add_adds_the_elements_of_b_to_a_at_corresponding_indicies
-    assert_equal [2,3,4], add([1,3,-1], [1,0,5])
-  end
-  
-  def test_add_multiplies_the_elements_of_b_by_factor
-    assert_equal [3,3,9], add([1,3,-1], [1,0,5], 2)
-    assert_equal [1,3,-1], add([1,3,-1], [1,0,5], 0)
-  end
-  
-  def test_add_removes_trailing_zeros_from_a
-    assert_equal [], add([1,1,1], [-1,-1,-1])
-  end
-  
-  def test_add_returns_a
-    a = [1,2,4]
-    assert_equal a.object_id, add(a, [1,0,4]).object_id
-  end
-  
-  def test_add_does_not_require_a_and_b_to_be_the_same_length
-    a = [1,2]
-    b = [1]
-    
-    assert_equal [2,2], add(a, b)
-    
-    a = [1,2]
-    b = [1]
-    
-    assert_equal [2,2], add(b, a)
-  end
-  
-  #
-  # multiply test
-  #
-  
-  def test_multiply_multiplies_elements_of_a_by_factor
-    assert_equal [2,4,-6], multiply([1,2,-3], 2)
-    assert_equal [-2,-4,6], multiply([1,2,-3], -2)
-  end
-  
-  def test_multiply_clears_a_for_zero_factor
-    assert_equal [], multiply([1,2,-3], 0)
-  end
-  
-  def test_mulitply_returns_a
-    a = [1,2,4]
-    assert_equal a.object_id, multiply(a, 2).object_id
-    assert_equal a.object_id, multiply(a, 0).object_id
-  end
-  
-  #
-  # count test
-  #
-  
-  def test_count_documenation
-    assert_equal [3, 2, 2] , count("abcabca", ["a", "b", "c"])
-    assert_equal [3, 4], count("abcabca", ["a", "bc"])
-  end
-  
-  #
-  # benchmark tests
-  #
-  
-  def test_round_speed
-    benchmark_test(24) do |x|
-      n = 100
-      x.report("#{n}k 1234.5678.round") do 
-        (n*10**3).times { 1234.5678.round }
-      end
-      
-      x.report("#{n}k 1234.5678 (2)") do 
-        (n*10**3).times { round(1234.5678, 2) }
-      end
-      
-      x.report("#{n}k 1234.5678 (5)") do 
-        (n*10**3).times { round(1234.5678, 5) }
-      end
-    end
-  end
-  
-  def test_add_speed
-    benchmark_test(30) do |x|
-      n = 100
-      x.report("#{n}k add([1,3,-1], [1,0,5])") do 
-        (n*10**3).times { add([1,3,-1], [1,0,5]) }
-      end
-      
-      x.report("#{n}k add([1,3,-1], [1])") do 
-        (n*10**3).times { add([1,3,-1], [1]) }
-      end
-      
-      x.report("#{n}k add([1], [1,3,-1])") do 
-        (n*10**3).times { add([1], [1,3,-1]) }
-      end
-      
-      x.report("#{n}k add([1,1,1], [-1,-1,-1])") do 
-        (n*10**3).times { add([1,1,1], [-1,-1,-1]) }
-      end
-      
-      x.report("#{n}k add([1,3,-1], [1,0,5], 2)") do 
-        (n*10**3).times { add([1,3,-1], [1,0,5], 2) }
-      end
-    end
-  end
-    
-  def test_multiply_speed
-    benchmark_test(30) do |x|
-      n = 100
-      x.report("#{n}k multiply([1,3,-1], 2)") do 
-        (n*10**3).times { multiply([1,3,-1], 2) }
-      end
-      
-      x.report("#{n}k multiply([1,3,-1], 0)") do 
-        (n*10**3).times { multiply([1,3,-1], 0) }
-      end
-    end
-  end
-  
-end

data/test/molecules_test.rb

@@ -1,24 +0,0 @@
-require File.expand_path( File.join(File.dirname(__FILE__), 'molecules_test_helper.rb') )
-require 'molecules'
-
-class MoleculesTest < Test::Unit::TestCase
- 
-  include Molecules::Libraries
-  
-  def test_readme_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
-    assert_in_delta 71.03711, r.mass, 0.00001
-    assert_in_delta 44.05002, r.immonium_ion_mass, 0.00001
-  
-    p = Polypeptide.new("RPPGFSPFR")
-    assert_equal "C(50)H(71)N(15)O(10)", p.to_s
-    assert_in_delta 1041.5508, p.mass , 0.0001
-  
-    caffeine = Molecules::EmpiricalFormula.parse("C8H10N4O2")
-    coffee = Molecules::EmpiricalFormula.parse("C8H10N4O2 + H2O")
-  end
-end

data/test/molecules_test_helper.rb

@@ -1,31 +0,0 @@
-require 'rubygems'
-require 'test/unit'
-require 'benchmark'
-require 'pp'
-
-class Test::Unit::TestCase
-  include Benchmark
-
-  #
-  # mass tests
-  #
-  
-  def delta_mass
-    10**-5
-  end
-  
-  def delta_abundance
-    10**-1
-  end
-  
-  def benchmark_test(length=10, &block) 
-    if ENV["benchmark"] =~ /true/i
-      puts
-      puts method_name
-      bm(length, &block)
-    else
-      print 'b'
-    end
-  end
-  
-end

data/test/molecules_test_suite.rb

@@ -1,3 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__), '../lib')
-
-Dir.glob("./**/*_test.rb").each {|test| require test}

data/test/tap_test_helper.rb

@@ -1,3 +0,0 @@
-require 'rubygems'
-require 'tap'
-require 'tap/test'