mspire 0.7.13 → 0.7.17

data/VERSION

@@ -1 +1 @@
-0.7.13
+0.7.17

data/lib/mspire/isotope/distribution.rb

@@ -107,12 +107,12 @@ module Mspire
   class Isotope
     module Distribution
       def self.calculate(molecular_formula_like, normalize=Mspire::Isotope::Distribution::NORMALIZE, percent_cutoff=nil)
-        mf = molecular_formula_like.is_a?(Mspire::MolecularFormula) ? molecular_formula_like : Mspire::MolecularFormula.new(molecular_formula_like)
+        mf = molecular_formula_like.is_a?(Mspire::MolecularFormula) ? molecular_formula_like : Mspire::MolecularFormula.from_any(molecular_formula_like)
         mf.isotope_distribution(normalize, percent_cutoff)
       end
 
       def self.spectrum(molecular_formula_like, normalize=Mspire::Isotope::Distribution::NORMALIZE, percent_cutoff=nil)
-        mf = molecular_formula_like.is_a?(Mspire::MolecularFormula) ? molecular_formula_like : Mspire::MolecularFormula.new(molecular_formula_like)
+        mf = molecular_formula_like.is_a?(Mspire::MolecularFormula) ? molecular_formula_like : Mspire::MolecularFormula.from_any(molecular_formula_like)
         mf.isotope_distribution_spectrum(normalize, percent_cutoff)
       end
     end

data/lib/mspire/mass.rb

@@ -4,11 +4,10 @@ require 'mspire/molecular_formula'
 module Mspire
   module Mass
 
-    # takes a molecular formula in this format: C2BrH12O
+    # takes a molecular formula as a string, hash or MolecularFormula object
+    # and returns the exact mass.
     def self.formula_to_exact_mass(formula)
-      Mspire::MolecularFormula.new(formula).map do |el,cnt|
-        MONO[el] * cnt
-      end.reduce(:+)
+      Mspire::MolecularFormula.from_any(formula).mass
     end
 
     MONO_STR = {

data/lib/mspire/molecular_formula.rb

@@ -4,46 +4,132 @@ require 'mspire/mass'
 module Mspire
   class MolecularFormula < Hash
 
+    class << self
+      def from_aaseq(aaseq)
+        hash = aaseq.each_char.inject({}) do |hash,aa| 
+          hash.merge(Mspire::Isotope::AA::FORMULAS[aa]) {|h,o,n| (o ? o : 0) +n }
+        end
+        hash[:h] += 2
+        hash[:o] += 1
+        self.new(hash)
+      end
+
+      # takes a string, with properly capitalized elements making up the
+      # formula.  The elements may be in any order.
+      def from_string(mol_form_str, charge=0)
+        mf = self.new({}, charge)
+        mol_form_str.scan(/([A-Z][a-z]?)(\d*)/).each do |k,v| 
+          mf[k.downcase.to_sym] = (v == '' ? 1 : v.to_i)
+        end
+        mf
+      end
+
+      # arg may be a String, Hash, or MolecularFormula object.
+      def from_any(arg, charge=0)
+        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
+
     # integer desribing the charge state
     # mass calculations will add/remove electron mass from this
     attr_accessor :charge
-    # takes a string or a hash:
-    #
-    #     "H22C12N1O3S2BeLi2"                    # <= order doesn't matter
+
+    # 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(arg, charge=0)
+    def initialize(hash={}, charge=0)
       @charge = charge
-      if arg.is_a?(String)
-        arg.scan(/([A-Z][a-z]?)(\d*)/).each do |k,v| 
-          self[k.downcase.to_sym] = (v == '' ? 1 : v.to_i)
-        end
-      else
-        self.merge!(arg)
-      end
+      self.merge!(hash)
     end
 
     # returns a new formula object where all the atoms have been added up
     def +(*others)
-      new_form = self.dup
-      others.each do |form|
-        new_form.merge!(form) {|key, oldval, newval| new_form[key] = oldval+newval }
+      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
-      new_form
+      self.charge *= int if also_do_charge
+      self
     end
 
-    def self.from_aaseq(aaseq)
-      hash = aaseq.each_char.inject({}) do |hash,aa| 
-        hash.merge(Mspire::Isotope::AA::FORMULAS[aa]) {|h,o,n| (o ? o : 0) +n }
+    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
-      hash[:h] += 2
-      hash[:o] += 1
-      self.new(hash)
+      self
     end
 
-    # gives the monoisotopic mass adjusted by the current charge
-    def 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) {|sum,(el,cnt)| sum + (Mspire::Mass::MONO[el]*cnt) }
-      mss - (Mspire::Mass::ELECTRON * charge)
+      mss -= (Mspire::Mass::ELECTRON * charge) if consider_electron_masses
+      mss
+    end
+
+    # returns nil if the charge == 0
+    def mz(consider_electron_masses = true)
+      if charge == 0
+        nil
+      else
+        mass(consider_electron_masses) / charge
+      end
     end
 
     def to_s(alphabetize=true)

data/spec/mspire/isotope/distribution_spec.rb

@@ -49,7 +49,7 @@ describe 'Mspire::Isotope::Distribution class methods' do
     end
 
     it 'gives proper m/z values if the molecule is charged' do
-      charged_molecule = Mspire::MolecularFormula.new( subject )
+      charged_molecule = Mspire::MolecularFormula.from_any( subject )
       charged_molecule.charge = -3
       spec = Mspire::Isotope::Distribution.spectrum( charged_molecule )
       [:mzs, :intensities].each {|att| spec.send(att).size.should == 253 }

data/spec/mspire/molecular_formula_spec.rb

@@ -2,52 +2,109 @@ require 'spec_helper'
 
 require 'mspire/molecular_formula'
 
+MF = Mspire::MolecularFormula
 describe Mspire::MolecularFormula do
 
-  it 'can be initialized with a String or Hash' do
-    data = {h: 22, c: 12, n: 1, o: 3, s: 2}
-    mf = Mspire::MolecularFormula.new "H22BeC12N1O3S2Li2"
-    mf.to_hash.should == {:h=>22, :be=>1, :c=>12, :n=>1, :o=>3, :s=>2, :li=>2}
-    mf = Mspire::MolecularFormula.new(data)
-    mf.to_hash.should == data
-  end
+  describe 'initialization' do
 
-  it 'can be initialized with charge, too' do
-    mf = Mspire::MolecularFormula.new "H22BeC12N1O3S2Li2", 2
-    mf.to_hash.should == {:h=>22, :be=>1, :c=>12, :n=>1, :o=>3, :s=>2, :li=>2}
-    mf.charge.should == 2
-  end
+    it 'is initialized with Hash' do
+      data = {h: 22, c: 12, n: 1, o: 3, s: 2}
+      mf = Mspire::MolecularFormula.new(data)
+      mf.to_hash.should == {:h=>22, :c=>12, :n=>1, :o=>3, :s=>2}
+      mf.to_hash.should == data
+    end
 
-  it 'expects properly capitalized abbreviations' do
-    Mspire::MolecularFormula.new('Ni7Se3').to_hash.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.
-    Mspire::MolecularFormula.new('Ni7SE3').to_hash.should == {:ni=>7, :s=>1, :e=>3}
-  end
+    it 'can be initialized with charge, too' do
+      mf = Mspire::MolecularFormula["H22BeC12N1O3S2Li2", 2]
+      mf.to_hash.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
+      Mspire::MolecularFormula.from_string("H22BeC12N1O3S2Li2").to_hash.should == {:h=>22, :be=>1, :c=>12, :n=>1, :o=>3, :s=>2, :li=>2}
+
+      mf = Mspire::MolecularFormula['Ni7Se3', 1]
+      mf.charge.should == 1
+      mf.to_hash.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.
+      Mspire::MolecularFormula['Ni7SE3'].to_hash.should == {:ni=>7, :s=>1, :e=>3}
+    end
 
-  describe 'an object' do
-    
-    subject {
-      data = {h: 22, c: 12, n: 1, o: 3, s: 2, be: 1}
-      Mspire::MolecularFormula.new(data)
-    }
+    describe 'conversion' do
 
-    it 'the string output is a standard molecular formula' do
-      subject.to_s.should == "BeC12H22NO3S2"
+      subject {
+        data = {h: 22, c: 12, n: 1, o: 3, s: 2, be: 1}
+        Mspire::MolecularFormula.new(data)
+      }
+
+      it 'the string output is a standard molecular formula' do
+        subject.to_s.should == "BeC12H22NO3S2"
+      end
+
+      it 'can be converted to a hash' do
+        subject.to_hash.should == {h: 22, c: 12, n: 1, o: 3, s: 2, be: 1}
+      end
     end
 
-    it 'can be converted to a hash' do
-      subject.to_hash.should == {h: 22, c: 12, n: 1, o: 3, s: 2, be: 1}
+    describe 'equality' do
+      subject {
+        data = {h: 22, c: 12, n: 1, o: 3, s: 2, be: 1}
+        Mspire::MolecularFormula.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
 
-    it 'is only equal if the charge is equal' do
-      another = subject.dup
-      another.should == subject
-      another.charge = 2
-      another.should_not == subject
+    describe 'arithmetic' do
+      subject {
+        data = {h: 22, c: 12, n: 1, o: 3, s: 2, be: 1}
+        Mspire::MolecularFormula.new(data, 2)
+      }
+      it 'can do non-destructive arithmetic' do
+        orig = subject.dup
+        reply = subject + MF["H2C3P2", 2]
+        reply.to_hash.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_hash.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_hash.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_hash.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_hash.should == {h: 20, c: 9, n: 1, o: 3, s: 2, be: 1}
+        subject.should_not == orig
+        subject.add!(MF["H2C3"]).to_hash.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_hash.should == {h: 44, c: 24, n: 2, o: 6, s: 4, be: 2}
+        by2.div!(2).to_hash.should == {h: 22, c: 12, n: 1, o: 3, s: 2, be: 1}
+        by2.to_hash.should == orig
+      end
+
     end
 
   end
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mspire
 version: !ruby/object:Gem::Version
-  version: 0.7.13
+  version: 0.7.17
   prerelease: 
 platform: ruby
 authors:
@@ -390,7 +390,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.18
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: mass spectrometry proteomics, lipidomics, and tools