mspire-molecular_formula 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8aa1b3d4118e17b3ca2c9092e9c355f6e376a46c
+  data.tar.gz: 14d52e1251c536369476ec68bab41f903a366a11
+SHA512:
+  metadata.gz: ee4729ebc0ff0276ffbd299bdec26a3eea81a05603895c1061b333031c8c22b53c1bac56789734a7e071dd776df728041f1dd67f0ca2ae4f61be6192aca87a77
+  data.tar.gz: d6301ed9ef9b458c80b80ea92615c059f6a49bbedc15ed76c1a5f089aac3766cb2d52d7063858bbb4704080fff8ade679bc18049f0d223e44e945c33d8f4ea65

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mspire-molecular_formula.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2014 Brigham Young University
+Author: John T. Prince
+
+MIT License
+
+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 without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,58 @@
+# Mspire::MolecularFormula
+
+mspire library to handle molecular formulas (including an optional charge state), complete with relevant chemical properties such as mass, m/z, and isotope distribution.
+
+## Installation
+
+    gem install mspire-molecular_formula
+
+## Usage
+
+```ruby
+require 'mspire/molecular_formula'
+```
+
+### Create with a hash
+
+```ruby
+mf = Mspire::MolecularFormula.new( C:3, H:4, O:2 )
+
+# with a +2 charge
+mf = Mspire::MolecularFormula.new( {C:3, H:4, O:2}, 2)
+```
+
+### Create with a string formula
+
+```ruby
+mf = Mspire::MolecularFormula[ 'C3H4O2' ]
+
+# with a +2 charge
+mf = Mspire::MolecularFormula[ 'C3H4O2', 2 ]
+mf = Mspire::MolecularFormula[ 'C3H4O2+2' ]  # alternatively
+mf = Mspire::MolecularFormula[ 'C3H4O2++' ]  # alternatively
+```
+
+### Arithmetic
+
+Walk through the arithmetic of combustion of ethene using this equation:
+
+    CH2=CH2 + 3 O2 -> 2 CO2 + 2 H2O 
+
+```ruby
+ethene = Mspire::MolecularFormula['C2H4']
+oxygen = Mspire::MolecularFormula['O2']
+water = Mspire::MolecularFormula['H2O']
+
+combustion = ethene + (oxygen*3)
+two_carbon_dioxide = combustion - (water*2)
+carbon_dioxide = two_carbon_dioxide / 2
+```
+
+Note that there are no methods defined on fixnum to deal with MolecularFormula
+objects, so fixnums need to follow the MolecularFormula (i.e., "3 * oxygen"
+will throw an error but "oxygen * 3" is fine)
+
+
+require 'mspire/isotope/distribution'  # requires fftw gem
+puts butane.isotope_distribution  # :total, :max, :first as arg to normalize
+

data/Rakefile

@@ -0,0 +1,24 @@
+require "bundler/gem_tasks"
+
+@module_name = Mspire::MolecularFormula
+@gem_name = 'mspire-molecular_formula'
+@gem_path_name = @gem_name.gsub('-','/')
+
+require "#{@gem_path_name}/version"
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = @module_name.const_get('VERSION')
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "#{@gem_name} #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/mspire/mf.rb

@@ -0,0 +1,3 @@
+require 'mspire/molecular_formula'
+
+Mspire::MF = Mspire::MolecularFormula

data/lib/mspire/molecular_formula.rb

@@ -0,0 +1,69 @@
+module Mspire
+  class MolecularFormula < Hash
+
+    # integer desribing the charge state
+    # mass calculations will add/remove electron mass from this
+    attr_accessor :charge
+
+    # Takes a hash and an optional Integer expressing the charge
+    #     {H: 22, C: 12, N: 1, O: 3, S: 2}  # case and string/sym doesn't matter
+    def initialize(hash={}, charge=0)
+      @charge = charge
+      self.merge!(hash)
+    end
+
+    def to_s(include_charge_if_nonzero=true, alphabetize=true)
+      h = alphabetize ? self.sort : self
+      st = ''
+      h.each do |k,v|
+        if v > 0
+          st << k.to_s.capitalize
+          st << v.to_s if v > 1
+        end
+      end
+      if include_charge_if_nonzero
+        st << "#{charge > 0 ? '+' : '-'}#{charge.abs if charge.abs > 1}" unless charge.zero?
+      end
+      st
+    end
+
+    def inspect
+      "{MolecularFormula #{super[1...-1]}, @charge=#{self.charge}}"
+    end
+
+    # returns a hash (note: does not pass along charge info!)
+    def to_h
+      Hash[ self ]
+    end
+
+    alias_method :old_equal, '=='.to_sym
+
+    def ==(other)
+      old_equal(other) && self.charge == other.charge
+    end
+
+  end
+end
+
+require "mspire/molecular_formula/version"
+
+# class methods for reading from different string input
+require 'mspire/molecular_formula/reader'
+
+# the modules for these 3 are included at the bottom
+require 'mspire/molecular_formula/arithmetic'
+require 'mspire/molecular_formula/mass'
+require 'mspire/molecular_formula/isotope_distribution'
+
+module Mspire
+  class MolecularFormula
+    extend Reader
+     
+    ####################################################
+    # include other behaviors
+    ####################################################
+    include Arithmetic
+    include Mass
+    include IsotopeDistribution
+  end
+end

data/lib/mspire/molecular_formula/aa.rb

@@ -0,0 +1,79 @@
+require 'mspire/molecular_formula'
+
+module Mspire
+  class MolecularFormula
+    module AA
+      # These represent counts for the individual residues (i.e., no extra H
+      # and OH on the ends)
+      aa_to_el_hash = {
+        'A' => { C: 3, H: 5, O: 1, N: 1 },
+        'C' => { C: 3, H: 5, O: 1, N: 1, S: 1 },
+        'D' => { C: 4, H: 5, O: 3, N: 1 },
+        'E' => { C: 5, H: 7, O: 3, N: 1 },
+        'F' => { C: 9, H: 9, O: 1, N: 1 },
+        'G' => { C: 2, H: 3, O: 1, N: 1 },
+        'I' => { C: 6, H: 11, O: 1, N: 1 },
+        'H' => { C: 6, H: 7, O: 1, N: 3 },
+        'K' => { C: 6, H: 12, O: 1, N: 2 },
+        'L' => { C: 6, H: 11, O: 1, N: 1 },
+        'M' => { C: 5, H: 9, O: 1, N: 1, S: 1 },
+        'N' => { C: 4, H: 6, O: 2, N: 2 },
+        'O' => { C: 12, H: 19, O: 2, N: 3 },
+        'P' => { C: 5, H: 7, O: 1, N: 1 },
+        'Q' => { C: 5, H: 8, O: 2, N: 2 },
+        'R' => { C: 6, H: 12, O: 1, N: 4 },
+        'S' => { C: 3, H: 5, O: 2, N: 1 },
+        'T' => { C: 4, H: 7, O: 2, N: 1 },
+        'U' => { C: 3, H: 5, O: 1, N: 1, Se: 1 },
+        'V' => { C: 5, H: 9, O: 1, N: 1 },
+        'W' => { C: 11, H: 10, O: 1, N: 2 },
+        'Y' => { C: 9, H: 9, O: 2, N: 1 },
+      }
+
+      # molecular formulas for each amino acid residue (no H or OH on ends)
+      # keyed by AA string.  Shares formula objects with FORMULAS_SYBMOL and
+      # FORMULAS.
+      FORMULAS_STRING = aa_to_el_hash.map {|k,v| [k, Mspire::MolecularFormula.new(v)] }.to_h
+
+      class << self
+        # returns hash of molecular formulas keyed by amino acid single letter
+        # symbol
+        #
+        # options:
+        #
+        #     :by =  :symbol | :string | :both
+        #     (:symbol is default)
+        def formulas(by: :symbol)
+          case by
+          when :symbol, :both
+            sym_hash = Mspire::MolecularFormula::AA::FORMULAS_STRING.map {|k,v| [k.to_sym, v] }.to_h
+          when :string
+            return Mspire::MolecularFormula::AA::FORMULAS_STRING
+          else
+            raise ArgumentError, ":by must be :symbol, :string, or :both"
+          end
+
+          if by == :symbol
+            sym_hash
+          else
+            Mspire::MolecularFormula::AA::FORMULAS_STRING.merge(sym_hash)
+          end
+        end
+      end
+    end
+
+    module Reader
+
+      # a linear peptide (so includes all the residue masses plus water)
+      def from_aaseq(aaseq, charge=0, aa_formula_hash=Mspire::MolecularFormula::AA::FORMULAS_STRING)
+        hash = aaseq.each_char.inject({}) do |hash,aa| 
+          hash.merge(aa_formula_hash[aa]) {|hash,old,new| (old ? old : 0) + new }
+        end
+        hash[:H] += 2
+        hash[:O] += 1
+        self.new(hash, charge)
+      end
+    end
+
+  end # molecular_formula
+end # mspire

data/lib/mspire/molecular_formula/arithmetic.rb

@@ -0,0 +1,74 @@
+module Mspire
+  class MolecularFormula
+    module Arithmetic
+      # returns a new formula object where all the atoms have been added up
+      def +(*others)
+        self.dup.add!(*others)
+      end
+
+      # returns self
+      def add!(*others)
+        others.each do |other|
+          self.merge!(other) {|key, oldval, newval| self[key] = oldval + newval }
+          self.charge += other.charge
+        end
+        self
+      end
+
+      # returns a new formula object where all the formulas have been subtracted
+      # from the caller
+      def -(*others)
+        self.dup.sub!(*others)
+      end
+
+      def sub!(*others)
+        others.each do |other|
+          oth = other.dup
+          self.each do |k,v|
+            if oth.key?(k)
+              self[k] -= oth.delete(k)
+            end
+          end
+          oth.each do |k,v|
+            self[k] = -v
+          end
+          self.charge -= other.charge
+        end
+        self
+      end
+
+      def *(int)
+        self.dup.mul!(int)
+      end
+
+      def mul!(int, also_do_charge=true)
+        raise ArgumentError, "must be an integer" unless int.is_a?(Integer)
+        self.each do |k,v|
+          self[k] = v * int
+        end
+        self.charge *= int if also_do_charge
+        self
+      end
+
+      def /(int)
+        self.dup.div!(int)
+      end
+
+      def div!(int, also_do_charge=true)
+        raise ArgumentError, "must be an integer" unless int.is_a?(Integer)
+        self.each do |k,v|
+          quotient, modulus = v.divmod(int)
+          raise ArgumentError "all numbers must be divisible by int" unless modulus == 0
+          self[k] = quotient
+        end
+        if also_do_charge
+          quotient, modulus = self.charge.divmod(int) 
+          raise ArgumentError "charge must be divisible by int" unless modulus == 0
+          self.charge = quotient
+        end
+        self
+      end
+
+    end
+  end
+end

data/lib/mspire/molecular_formula/isotope_distribution.rb

@@ -0,0 +1,109 @@
+require 'mspire/mass'
+require 'mspire/isotope'
+
+require 'fftw3'
+
+module Mspire
+  class MolecularFormula
+    module IsotopeDistribution
+      NORMALIZE = :total
+
+      # Returns isotopic distribution beginning with the lightest possible peak.
+      # (for most molecules this will also be the monoisotopic peak)
+      #
+      # Two cutoff protocols may be specified, percent_cutoff or
+      # peak_cutoff.  Normalization is performed *after* cutoff.
+      #
+      #     percent_cutoff: cuts off when no more peaks contribute more than percent_cutoff 
+      #                         to the total distribution.  
+      #     peak_cutoff:    cuts off after that many peaks.
+      #
+      # prefer_lowest_index controls the behavior if both percent_cutoff and
+      # peak_cutoff are specified.  If true, then the lowest index found between
+      # the two methods will be used, otherwise the highest index.
+      #
+      # all values will be fractional.  normalize may be one of:
+      #
+      #     :total   normalize to the total intensity
+      #     :max     normalize to the highest peak intensity
+      #     :first   normalize to the intensity of the first peak 
+      #             (this is typically the monoisotopic peak)
+      def isotope_intensity_distribution(normalize: NORMALIZE, peak_cutoff: nil, percent_cutoff: nil, prefer_lowest_index: true, isotope_table: Mspire::Isotope::BY_ELEMENT)
+        mono_dist = raw_isotope_distribution(isotope_table: isotope_table)
+
+        cutoff_index = [ 
+          if percent_cutoff
+            total_signal = mono_dist.reduce(:+)
+            cutoff_index_less1 = (mono_dist.size-1).downto(0).find do |i|
+              # finds the index
+              (mono_dist[i] / total_signal) >= (percent_cutoff/100.0)
+            end
+            cutoff_index = cutoff_index_less1 ? (cutoff_index_less1 + 1) : 0
+        end,
+        peak_cutoff
+        ].compact.send( prefer_lowest_index ? :min : :max ) || mono_dist.size
+
+        # mono_dist.size will result in nothing sliced off (i.e., for no cutoff)
+
+        mono_dist.slice!(cutoff_index..-1)
+
+        # normalization
+        norm_by =
+          case normalize
+          when :total
+            total_signal || mono_dist.reduce(:+)
+          when :max
+            mono_dist.max
+          when :first
+            mono_dist.first
+          end
+        mono_dist.map do |i| 
+          v = i / norm_by
+          (v > 0) ? v : 0
+        end
+      end
+
+      # returns an array of two arrays: mass values (or m/z values of charged)
+      # and intensity values.  Arguments are passed directly to
+      # isotope_intensity_distribution.  the molecule has a charge, this will be
+      # used to adjust the m/z values (by removing or adding electrons to the
+      # m/z and as the z)
+      def isotope_distribution(*args)
+        intensities = isotope_intensity_distribution(*args)
+        #mono = self.map {|el,cnt| Mspire::Mass::Element::MONO[el]*cnt }.reduce(:+)
+        mono = self.map {|el,cnt| Mspire::Isotope::BY_ELEMENT[el].find(&:mono).atomic_mass*cnt }.reduce(:+)
+        masses = Array.new(intensities.size)
+        neutron = Mspire::Mass::NEUTRON
+        masses[0] = mono
+        (1...masses.size).each {|i| masses[i] = masses[i-1] + neutron }
+        if self.charge && self.charge != 0
+          masses.map! do |mass| 
+            (mass - (self.charge * Mspire::Mass::ELECTRON)) / self.charge 
+          end
+        end
+        [masses, intensities]
+      end
+
+      # returns relative ratios from low nominal mass to high nominal mass.
+      # These are *not* normalized at all.
+      def raw_isotope_distribution(isotope_table: Mspire::Isotope::BY_ELEMENT)
+        low_nominal = 0
+        high_nominal = 0
+        self.each do |el,cnt|
+          isotopes = isotope_table[el]
+          low_nominal += (isotopes.first.mass_number * cnt)
+          high_nominal += (isotopes.last.mass_number * cnt)
+        end
+
+        ffts = self.map do |el, cnt|
+          isotope_el_ar = NArray.float(high_nominal+1)
+          isotope_table[el].each do |isotope|
+            isotope_el_ar[isotope.mass_number] = isotope.relative_abundance
+          end
+          FFTW3.fft(isotope_el_ar)**cnt
+        end
+        FFTW3.ifft(ffts.reduce(:*)).real.to_a[low_nominal..high_nominal]
+      end
+    end
+  end
+end

data/lib/mspire/molecular_formula/mass.rb

@@ -0,0 +1,34 @@
+require 'mspire/mass'
+
+module Mspire
+  class MolecularFormula
+    module Mass
+      # gives the monoisotopic mass adjusted by the current charge (i.e.,
+      # adds/subtracts electron masses for the charges)
+      def mass(consider_electron_masses = true)
+        mss = inject(0.0) do |sum,(el,cnt)| 
+          sum + (Mspire::Mass::Element::MONO_STRING[el.to_s]*cnt)
+        end
+        mss -= (Mspire::Mass::ELECTRON * charge) if consider_electron_masses
+        mss
+      end
+
+      def avg_mass(consider_electron_masses = true)
+        mss = inject(0.0) {|sum,(el,cnt)| sum + (Mspire::Mass::Element::AVG_STRING[el.to_s]*cnt) }
+        mss -= (Mspire::Mass::ELECTRON * charge) if consider_electron_masses
+        mss
+      end
+
+      # the mass to charge ratio (m/z)
+      # returns nil if the charge == 0
+      def mz(consider_electron_masses = true, negative_mz_allowed = true)
+        if charge == 0
+          nil
+        else
+          mass(consider_electron_masses) / (negative_mz_allowed ? charge : charge.abs)
+        end
+      end
+    end
+  end
+end
+

data/lib/mspire/molecular_formula/reader.rb

@@ -0,0 +1,56 @@
+require 'mspire/molecular_formula/aa'
+
+module Mspire
+  class MolecularFormula
+    module Reader
+      # returns the formula portion and the charge portion (signed Int) of a string
+      # returns nil for charge if no charge specified.
+      # e.g. C2H4+3 => ['C2H4', 3]
+      # e.g. C2H4+++ => ['C2H4', 3]
+      # e.g. C2H4- => ['C2H4', -1]
+      def formula_and_charge(string)
+        md = string.match(/([^+-]*)([\+-]+)(\d*)\Z/)
+        if md
+          charges_string = md[2]
+          chrg = 
+            if md[3] != ''
+              md[2] == '-' ? -md[3].to_i : md[3].to_i
+            else
+              sign = charges_string[0]
+              cnt = charges_string.count(sign)
+              sign == '-' ? -cnt : cnt
+            end
+          [md[1], chrg]
+        else
+          [string, nil]
+        end
+      end
+
+    
+      # takes a string, with properly capitalized elements making up the
+      # formula.  The elements may be in any order. A charge (e.g., +2, +, -,
+      # -3 may be affixed to the end )
+      def from_string(arg, charge=nil)
+        (mol_form_str, chrg_from_str) = formula_and_charge(arg)
+        mf = self.new({}, charge || chrg_from_str || 0)
+        mol_form_str.scan(/([A-Z][a-z]?)(\d*)/).each do |k,v| 
+          mf[k.to_sym] = (v == '' ? 1 : v.to_i)
+        end
+        mf
+      end
+
+      # arg may be a String, Hash, or MolecularFormula object.
+      def from_any(arg, charge=nil)
+        if arg.is_a?(String)
+          from_string(arg, charge)
+        else
+          self.new(arg, arg.respond_to?(:charge) ? arg.charge : 0)
+        end
+      end
+      alias_method :[], :from_any
+
+    end
+  end
+end
+
+

data/lib/mspire/molecular_formula/version.rb

@@ -0,0 +1,5 @@
+module Mspire
+  class MolecularFormula < Hash
+    VERSION = "0.0.1"
+  end
+end

data/mspire-molecular_formula.gemspec

@@ -0,0 +1,39 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mspire/molecular_formula/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mspire-molecular_formula"
+  spec.version       = Mspire::MolecularFormula::VERSION
+  spec.authors       = ["John T. Prince"]
+  spec.email         = ["jtprince@gmail.com"]
+  spec.summary       = %q{mspire library to handle molecular formulas (including an optional charge state)}  
+  spec.description   = %q{mspire library to handle molecular formulas (including an optional charge state), complete with relevant chemical properties such as mass, m/z, and isotope distribution.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  [
+    ["mspire-mass", "~> 0.1.0"],  # which brings in mspire-isotope
+  ].each do |args|
+    spec.add_dependency(*args)
+  end
+
+  [
+    ["bundler", "~> 1.6.2"],
+    ["rake"],
+    ["rspec", "~> 2.14.1"], 
+    ["rdoc", "~> 4.1.1"], 
+    ["simplecov", "~> 0.8.2"],
+    # here because bad microsoft OS support
+    # TODO: implement w/o FFTW
+    ["fftw3", "~> 0.3"],
+  ].each do |args|
+    spec.add_development_dependency(*args)
+  end
+end

data/spec/mspire/mf_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+require 'mspire/mf'
+
+describe 'require "mspire/mf" to get Mspire::MF shorthand' do
+  specify 'Mspire::MF allows convenient access to MolecularFormula stuff' do
+    product = Mspire::MF['H2O'] + Mspire::MF['C2H4']
+    Mspire::MF['H2O+'].mass.should == 18.010016083700002
+  end
+end

data/spec/mspire/molecular_formula/aa_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+require 'mspire/molecular_formula/aa'
+
+describe Mspire::MolecularFormula::AA do
+  specify '::FORMULAS_STRING holds molecular formulas keyed by AA string' do
+    hash = Mspire::MolecularFormula::AA::FORMULAS_STRING
+    hash.size.should == 22
+    hash.values.each {|mf| mf.should be_a(Mspire::MolecularFormula) }
+    hash.values.first.to_h.should == { :C=>3, :H=>5, :O=>1, :N=>1 }
+    hash['A'].to_h.should == { :C=>3, :H=>5, :O=>1, :N=>1 }
+    hash.keys.all? {|key| key.is_a?(String) }.should be_true
+  end
+
+  specify '::formulas returns them by symbol or string  or both (symbol by default)' do
+    hash = Mspire::MolecularFormula::AA.formulas
+    hash.size.should == 22
+    hash.values.each {|mf| mf.should be_a(Mspire::MolecularFormula) }
+    hash.values.first.to_h.should == { :C=>3, :H=>5, :O=>1, :N=>1 }
+    hash.keys.all? {|key| key.is_a?(Symbol) }.should be_true
+    hash[:A].to_h.should == { :C=>3, :H=>5, :O=>1, :N=>1 }
+
+    hash = Mspire::MolecularFormula::AA.formulas(by: :string)
+    hash.keys.all? {|key| key.is_a?(String) }.should be_true
+    hash['A'].to_h.should == { :C=>3, :H=>5, :O=>1, :N=>1 }
+
+    hash = Mspire::MolecularFormula::AA.formulas(by: :both)
+    hash.keys.any? {|key| key.is_a?(Symbol) }.should be_true
+    hash.keys.any? {|key| key.is_a?(String) }.should be_true
+    hash['A'].to_h.should == { :C=>3, :H=>5, :O=>1, :N=>1 }
+    hash[:A].to_h.should == { :C=>3, :H=>5, :O=>1, :N=>1 }
+  end
+end

data/spec/mspire/molecular_formula/isotope_distribution_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+# in this case we need to pull in mol...form... first or we'll get it behaving
+# like a proper hash with ::[] since ::[] hasn't been overridden!
+require 'mspire/molecular_formula'
+
+describe 'Mspire::Isotope::Distribution class methods' do
+
+  def similar_distributions(a_dist, b_dist)
+    b_dist.zip(a_dist) do |b,a| 
+      expect(a).to be_within(1e-9).of b
+    end
+  end
+
+  before(:all) do
+    @nist = Mspire::Isotope::NIST::BY_ELEMENT
+    @norm = :total
+    @pcut = nil # percent cutoff
+  end
+
+  before do 
+    @first = [1.0, 0.08919230588715311, 0.017894161377222138, 0.0013573997600723345, 0.0001398330738144181]
+  end
+
+  # can also be used on a real MolecularFormula object
+  subject { Mspire::MolecularFormula['C102H120O15'] }
+
+  describe 'normalizing isotope distributions' do
+
+    it 'defaults to normalizing by total signal with no cutoff' do
+      
+      dist = subject.isotope_intensity_distribution(normalize: @norm, percent_cutoff: @pcut, isotope_table: @nist )
+      expect(dist.size).to eq(253)
+      similar_distributions dist[0,5], [0.31740518639058685, 0.35635707398291416, 0.20793431846543858, 0.08373257192958428, 0.026084566135229446]
+    end
+
+    it 'can normalize by first peak' do
+      dist = subject.isotope_intensity_distribution(normalize: :first, percent_cutoff: @pcut, isotope_table: @nist )
+      dist.size.should == 253
+      dist[0].should == 1.0
+      dist[1].should_not == 1.0
+    end
+
+    it 'can normalize by the max peak' do
+      dist = subject.isotope_intensity_distribution(normalize: :max, percent_cutoff: @pcut, isotope_table: @nist )
+      dist.size.should == 253
+      dist[0].should_not == 1.0
+      dist[1].should == 1.0
+    end
+
+    it 'can cutoff based on percent of total signal' do
+      subject.isotope_intensity_distribution(normalize: :max, percent_cutoff: 100, isotope_table: @nist).should == []
+      similar_distributions subject.isotope_intensity_distribution(normalize: :max, percent_cutoff: 20, isotope_table: @nist), [0.8906942209481861, 1.0, 0.5834999040187656]
+      similar_distributions subject.isotope_intensity_distribution(normalize: :max, percent_cutoff: 5, isotope_table: @nist), [0.8906942209481861, 1.0, 0.5834999040187656, 0.23496817670469172]
+      subject.isotope_intensity_distribution( normalize: :max, percent_cutoff: 0.0001, isotope_table: @nist).size.should == 11
+    end
+
+    it 'can cutoff based on a given number of peaks' do
+      subject.isotope_intensity_distribution(normalize: :max, peak_cutoff: 0, isotope_table: @nist).should == []
+      similar_distributions subject.isotope_intensity_distribution(normalize: :total, peak_cutoff: 4, isotope_table: @nist), [0.3287710818944283, 0.3691177894299527, 0.2153801947039964, 0.08673093397162249]
+      expect(subject.isotope_intensity_distribution(normalize: :max, peak_cutoff: 1, isotope_table: @nist)).to eql([1.0])
+    end
+    #xspecify 'prefers the lowest of cutoffs'  ## need to test
+  end
+
+  describe "calculating an isotope distribution (yielding masses/mz's and intensities)" do
+
+    it 'gives neutral masses if no charge' do
+      (mzs, intensities) = subject.isotope_distribution(normalize: @norm, percent_cutoff: @pcut, isotope_table: @nist )
+      [mzs, intensities].each {|ar| ar.size.should == 253 }
+      mzs[0,5].should == [1584.8627231418, 1585.8713880574, 1586.8800529730001, 1587.8887178886002, 1588.8973828042003]
+      similar_distributions intensities[0,5], [0.31740518639058685, 0.35635707398291416, 0.20793431846543858, 0.08373257192958428, 0.026084566135229446]
+    end
+
+    it 'gives proper m/z values if the molecule is charged' do
+      subject.charge = -3
+      (mzs, ints) = subject.isotope_distribution(normalize: @norm, percent_cutoff: @pcut, isotope_table: @nist )
+      [mzs, ints].each {|ar| ar.size.should == 253 }
+      mzs[0,5].should == [-528.2881229806, -528.6243446191334, -528.9605662576668, -529.2967878962, -529.6330095347334]
+    end
+  end
+end

data/spec/mspire/molecular_formula_spec.rb

@@ -0,0 +1,227 @@
+require 'spec_helper'
+
+require 'mspire/molecular_formula'
+
+MF = Mspire::MolecularFormula
+describe Mspire::MolecularFormula do
+
+  describe 'initialization' do
+
+    it 'is initialized with Hash' do
+      data = {H: 22, C: 12, N: 1, O: 3, S: 2}
+      mf = MF.new(data)
+      mf.to_h.should == {:H=>22, :C=>12, :N=>1, :O=>3, :S=>2}
+      mf.to_h.should == data
+    end
+
+    it 'can be initialized with charge, too' do
+      mf = MF["H22BeC12N1O3S2Li2", 2]
+      mf.to_h.should == {:H=>22, :Be=>1, :C=>12, :N=>1, :O=>3, :S=>2, :Li=>2}
+      mf.charge.should == 2
+    end
+
+    it 'from_string or ::[] to make from a capitalized string formula' do
+      MF.from_string("H22BeC12N1O3S2Li2").to_h.should == {:H=>22, :Be=>1, :C=>12, :N=>1, :O=>3, :S=>2, :Li=>2}
+
+      mf = MF['Ni7Se3', 1]
+      mf.charge.should == 1
+      mf.to_h.should == {:Ni=>7, :Se=>3}
+
+      # there is no such thing as the E element, so this is going to get the
+      # user in trouble.  However, this is the proper interpretation of the
+      # formula.
+      mf = MF['Ni7SE3']
+      mf.charge.should == 0
+      mf.to_h.should == {:Ni=>7, :S=>1, :E=>3}
+    end
+
+    specify 'Mspire::MolecularFormula.from_aaseq(seq) from an amino acide sequence' do
+      mf = MF.from_aaseq("ACDEFGIHKLMNOPQRSTUVWY")
+      # checked to be correct with http://web.expasy.org/protparam/
+      mf.to_h.should == {:C=>122, :H=>183, :O=>33, :N=>33, :S=>2, :Se=>1}
+    end
+
+    specify 'Mspire::MolecularFormula.from_aaseq(seq, charge) from an amino acide sequence with charge' do
+      mf = MF.from_aaseq("ACDEFGIHKLMNOPQRSTUVWY", 3)
+      mf.to_h.should == {:C=>122, :H=>183, :O=>33, :N=>33, :S=>2, :Se=>1}
+      mf.charge.should == 3
+    end
+
+    it 'from_string or ::[] to make from a capitalized string formula with charge attached' do
+      mf = MF.from_string("H22BeC12N1O3S2Li2+")
+      mf.charge.should == 1
+      mf.to_h.should == {:H=>22, :Be=>1, :C=>12, :N=>1, :O=>3, :S=>2, :Li=>2}
+
+      mf = MF.from_string("H22BeC12N1O3S2Li2++++")
+      mf.charge.should == 4
+      mf.to_h.should == {:H=>22, :Be=>1, :C=>12, :N=>1, :O=>3, :S=>2, :Li=>2}
+
+      mf = MF.from_string("H22BeC12N1O3S2Li2+4")
+      mf.charge.should == 4
+      mf.to_h.should == {:H=>22, :Be=>1, :C=>12, :N=>1, :O=>3, :S=>2, :Li=>2}
+
+      mf = MF.from_string("H22BeC12N1O3S2Li2-")
+      mf.charge.should == -1 
+      mf.to_h.should == {:H=>22, :Be=>1, :C=>12, :N=>1, :O=>3, :S=>2, :Li=>2}
+
+      mf = MF.from_string("H22BeC12N1O3S2Li2-3")
+      mf.charge.should == -3
+      mf.to_h.should == {:H=>22, :Be=>1, :C=>12, :N=>1, :O=>3, :S=>2, :Li=>2}
+    end
+  end
+
+  describe 'conversion (to_s and to_h)' do
+
+    subject {
+      data = {H: 22, C: 12, N: 1, O: 3, S: 2, Be: 1}
+      MF.new(data)
+    }
+
+    specify '#to_s a standard molecular formula, alphabetized by default' do
+      subject.to_s.should == "BeC12H22NO3S2"
+    end
+
+    specify '#to_s contains the charge by default' do
+      subject.charge = 3
+      subject.to_s.should == "BeC12H22NO3S2+3"
+      subject.charge = -3
+      subject.to_s.should == "BeC12H22NO3S2-3"
+    end
+
+    specify '#to_s(false) turns off charge' do
+      subject.charge = 3
+      subject.to_s(false).should == "BeC12H22NO3S2"
+      subject.charge = -3
+      subject.to_s(false).should == "BeC12H22NO3S2"
+    end
+
+    specify '#to_s(true, false) does not sort' do
+      subject.charge = 2
+      subject.to_s(true, false) == "H22C12NO3S2Be+2"
+    end
+
+    specify '#to_h converts to a hash' do
+      subject.charge = 2
+      subject.to_h.should == {H: 22, C: 12, N: 1, O: 3, S: 2, Be: 1}
+    end
+  end
+
+  describe 'equality' do
+    subject {
+      data = {H: 22, C: 12, N: 1, O: 3, S: 2, Be: 1}
+      MF.new(data)
+    }
+    it 'is only equal if the charge is equal' do
+      another = subject.dup
+      another.should == subject
+      another.charge = 2
+      another.should_not == subject
+    end
+  end
+
+  describe 'arithmetic' do
+    subject {
+      data = {H: 22, C: 12, N: 1, O: 3, S: 2, Be: 1}
+      MF.new(data, 2)
+    }
+    it 'can do non-destructive arithmetic' do
+      orig = subject.dup
+      reply = subject + MF["H2C3P2", 2]
+      reply.to_h.should == {H: 24, C: 15, N: 1, O: 3, S: 2, Be: 1, P: 2}
+      reply.charge.should == 4
+      subject.should == orig
+
+      reply = subject - MF["H2C3P2", 2]
+      reply.to_h.should == {H: 20, C: 9, N: 1, O: 3, S: 2, Be: 1, P: -2}
+      reply.charge.should == 0
+      subject.should == orig
+
+      by2 = subject * 2
+      by2.to_h.should == {H: 44, C: 24, N: 2, O: 6, S: 4, Be: 2}
+      by2.charge.should == 4
+      subject.should == orig
+
+      reply = by2 / 2
+      reply.to_h.should == {H: 22, C: 12, N: 1, O: 3, S: 2, Be: 1}
+      reply.charge.should == 2
+      subject.should == orig
+    end
+
+    it 'can do destructive arithmetic' do
+      orig = subject.dup
+      subject.sub!(MF["H2C3"]).to_h.should == {H: 20, C: 9, N: 1, O: 3, S: 2, Be: 1}
+      subject.should_not == orig
+      subject.add!(MF["H2C3"]).to_h.should == {H: 22, C: 12, N: 1, O: 3, S: 2, Be: 1}
+      subject.should == orig
+
+      by2 = subject.mul!(2)
+      subject.should_not == orig
+      by2.to_h.should == {H: 44, C: 24, N: 2, O: 6, S: 4, Be: 2}
+      by2.div!(2).to_h.should == {H: 22, C: 12, N: 1, O: 3, S: 2, Be: 1}
+      by2.to_h.should == orig
+    end
+
+  end
+
+  describe 'reading in a formula and charge from a string' do
+    subject { MF }
+    specify 'Mspire::MolecularFormula.formula_and_charge' do
+      subject.formula_and_charge( 'C2H4+3' ).should == ['C2H4', 3]
+      subject.formula_and_charge( 'C2H4+++' ).should == ['C2H4', 3]
+      subject.formula_and_charge( 'C2H4-').should == ['C2H4', -1]
+      subject.formula_and_charge( 'C2H4-2').should == ['C2H4', -2]
+    end
+  end
+
+  describe 'mass and mz' do
+    # (for all these, checked to make sure in close ballpark, but not
+    # necessarily exact, unless otherwise stated)
+
+    before do
+      @exact = 65.02654910101
+      @avg = 65.07332
+      @e = 0.0005486  # set with -> Mspire::Mass::ELECTRON
+      @exact_plus_2e = @exact + (2*@e)
+    end
+
+    subject {
+      data = {H: 3, C: 4, N: 1}
+      MF.new(data, -2)
+    }
+
+    specify '#mass (of an uncharged molecule) -> the exact mass' do
+      subject.charge = 0
+      subject.mass.should == @exact # BMRB databank says: 65.0265491015
+    end
+
+    specify '#mass -> the exact mass (adjusts for electrons)' do
+      subject.mass.should == @exact_plus_2e
+    end
+
+    specify '#mass (no charge adjustment)' do
+      subject.mass(false).should == @exact  # BMRB databank says: 65.0265491015
+    end
+
+    specify '#avg_mass' do
+      subject.avg_mass.should == (@avg + 2*@e)
+      # changes the value
+      subject.charge = 0
+      subject.avg_mass.should == @avg  # BMRB databank says: 65.073320
+    end
+
+    specify '#mz -> the m/z ratio' do
+      subject.mz.should == (@exact_plus_2e / -2.0)
+      subject.charge = +2
+      subject.mz.should == ((@exact - 2*@e) / 2.0)
+    end
+
+    specify '#mz(true, false) will only yield positive m/z ratio' do
+      subject.mz(true, false).should == (@exact_plus_2e / 2.0)
+    end
+
+    specify '#mz(false, true) will not consider electrons in mass determination' do
+      subject.mz(false, true).should == (@exact / -2.0)
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'rspec'
+
+TESTFILES = File.dirname(__FILE__) + '/testfiles'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.color_enabled = true
+  config.tty = true
+  config.formatter = :documentation  # :progress, :html, :textmate
+  #config.formatter = :progress # :progress, :html, :textmate
+end
+
+

metadata

@@ -0,0 +1,169 @@
+--- !ruby/object:Gem::Specification
+name: mspire-molecular_formula
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- John T. Prince
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mspire-mass
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.2
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.1
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+- !ruby/object:Gem::Dependency
+  name: fftw3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+description: mspire library to handle molecular formulas (including an optional charge
+  state), complete with relevant chemical properties such as mass, m/z, and isotope
+  distribution.
+email:
+- jtprince@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/mspire/mf.rb
+- lib/mspire/molecular_formula.rb
+- lib/mspire/molecular_formula/aa.rb
+- lib/mspire/molecular_formula/arithmetic.rb
+- lib/mspire/molecular_formula/isotope_distribution.rb
+- lib/mspire/molecular_formula/mass.rb
+- lib/mspire/molecular_formula/reader.rb
+- lib/mspire/molecular_formula/version.rb
+- mspire-molecular_formula.gemspec
+- spec/mspire/mf_spec.rb
+- spec/mspire/molecular_formula/aa_spec.rb
+- spec/mspire/molecular_formula/isotope_distribution_spec.rb
+- spec/mspire/molecular_formula_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: mspire library to handle molecular formulas (including an optional charge
+  state)
+test_files:
+- spec/mspire/mf_spec.rb
+- spec/mspire/molecular_formula/aa_spec.rb
+- spec/mspire/molecular_formula/isotope_distribution_spec.rb
+- spec/mspire/molecular_formula_spec.rb
+- spec/spec_helper.rb