mspire 0.6.2 → 0.6.6

data/LICENSE

@@ -1,13 +1,54 @@
-Copyright (c) 2006, The University of Texas at Austin("U.T. Austin"). All rights reserved.  
+(The MIT License)
 
-Software by John T. Prince under the direction of Edward M. Marcotte.
+Copyright (c) 2011 Brigham Young University
+authored by John T. Prince
 
-By using this software the USER indicates that he or she has read, understood and will comply with the following:
+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:
 
-U. T. Austin hereby grants USER permission to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of this software and its documentation for any purpose and without fee, provided that a full copy of this notice is included with the software and its documentation.
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
 
-Title to copyright this software and its associated documentation shall at all times remain with U. T. Austin. No right is granted to use in advertising, publicity or otherwise any trademark, service mark, or the name of U. T. Austin.
+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.
 
-This software and any associated documentation are provided "as is," and U. T. AUSTIN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESSED OR IMPLIED, INCLUDING THOSE OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, OR THAT USE OF THE SOFTWARE, MODIFICATIONS, OR ASSOCIATED DOCUMENTATION WILL NOT INFRINGE ANY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER INTELLECTUAL PROPERTY RIGHTS OF A THIRD PARTY. U. T. Austin, The University of Texas System, its Regents, officers, and employees shall not be liable under any circumstances for any direct, indirect, special, incidental, or consequential damages with respect to any claim by USER or any third party on account of or arising from the use, or inability to use, this software or its associated documentation, even if U. T. Austin has been advised of the possibility of those damages.
+========================================================================
+The following files are under the following license:
+ms/spectrum.rb
+========================================================================
 
-Submit software operation questions to: Edward M. Marcotte, Department of Chemistry and Biochemistry, U. T. Austin, Austin, Texas 78712.
+(The MIT License)
+
+Copyright (c) 2006-2010 University of Texas at Austin, Howard Hughes Medical
+Institute, Reagents of the University of Colorado, and Brigham Young
+University
+
+Authored by John T. Prince and Simon Chiang.
+
+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/Rakefile

@@ -14,6 +14,7 @@ Jeweler::Tasks.new do |gem|
   gem.authors = ["John T. Prince", "Simon Chiang"]
   gem.add_dependency "nokogiri", "~> 1.5"
   gem.add_dependency "bsearch", ">= 1.5.0"
+  gem.add_dependency "andand", ">= 1.3.1"
   gem.add_dependency "obo", ">= 0.1.0"
   gem.add_development_dependency "rspec", "~> 2.6"
   gem.add_development_dependency "jeweler", "~> 1.5.2"

data/VERSION

@@ -1 +1 @@
-0.6.2
+0.6.6

data/lib/bin.rb

@@ -0,0 +1,65 @@
+
+class Bin < Range
+  attr_accessor :data
+
+  def initialize(*args)
+    super(*args)
+    @data = []
+  end
+
+  def inspect
+    "<(" + super + ") @data=#{data.inspect}>"
+  end
+
+  def <<(val)
+    @data << val
+  end
+
+  # O(m + n) speed to bin objects.
+  # bin objects must respond to === .
+  # the object to bin must be a value that is sortable (< > ==), or you can
+  # pass in a block to get the value.
+  # bins and objects must be accessible by index (e.g., bins[11]).
+  # if data_capture is given, it should be a parallel array to bins, and each
+  # object should respond to the '<<' method.  Otherwise, the bins themselves
+  # will be used to push data onto.
+  #
+  # Here's a simple example of binning x,y points where we want to bin the
+  # points based on the x value:
+  #
+  #     bins = (0...10).map {|i| Bin.new(i, i+1, false) }
+  #     points = [[2.2, 100], [3.5, 200], [8.8, 150]]
+  #
+  #     Bin.bin!(bins, points) {|point| point.first }
+  #     # --or--:     Bin.bin!(bins, points, &:first)
+  #
+  # An example where we want to use a separate data store:
+  #
+  #
+  def self.bin(bins, objects, *data_capture_obj, &block)
+    obj_e = objects.each ; obj = obj_e.next  
+
+    data_capture = data_capture_obj.first || bins
+
+    bin_i = 0  # the bin index
+    cbin = bins[bin_i]  # the current bin
+    done = false
+    until done
+      value = (block.nil? ? obj : block.call(obj))
+      if cbin.begin <= value
+        until cbin === value && data_capture[bin_i] << obj
+          bin_i += 1
+          cbin=bins[bin_i] || (done=true && break)
+        end
+        obj=obj_e.next rescue done=true
+      else
+        while cbin.begin > value && !done
+          obj=obj_e.next rescue done=true && break
+          value = (block.nil? ? obj : block.call(obj))
+        end
+      end
+    end
+    data_capture
+  end
+
+end

data/lib/core_ext/array/in_groups.rb

@@ -0,0 +1,29 @@
+
+class Array
+  # copied from ActiveSupport CoreExtensions
+  def in_groups(number, fill_with = nil)
+    # size / number gives minor group size;
+    # size % number gives how many objects need extra accomodation;
+    # each group hold either division or division + 1 items.
+    division = size / number
+    modulo = size % number
+
+    # create a new array avoiding dup
+    groups = []
+    start = 0
+
+    number.times do |index|
+      length = division + (modulo > 0 && modulo > index ? 1 : 0)
+      padding = fill_with != false &&
+        modulo > 0 && length == division ? 1 : 0
+      groups << slice(start, length).concat([fill_with] * padding)
+      start += length
+    end
+
+    if block_given?
+      groups.each{|g| yield(g) }
+    else
+      groups
+    end
+  end
+end

data/lib/ms/ident/protein.rb

@@ -11,13 +11,13 @@ module MS::Ident
     alias_method :seq, :sequence
     alias_method :seq=, :sequence=
 
-      # a description of the protein
-      attr_accessor :description
+    # a description of the protein
+    attr_accessor :description
 
     # if the GN=([^\s]+) regexp is found in the description, returns the first
     # match, or nil if not found
     def gene_id
-      description.andand.match(/ GN=(\w+) ?/)[1]
+      description.andand[/ GN=(\w+) ?/, 1]
     end
   end
 

data/lib/ms/isotope/aa.rb

@@ -1,55 +1,33 @@
 module MS
   module Isotope
     module AA
+      # These represent counts for the individual residues (i.e., no extra H
+      # and OH on the ends)
       ATOM_COUNTS_STR = {
-        'A' => { :c =>3, :h =>7 , :o =>2 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
-        'R' => { :c =>6, :h =>14 , :o =>2 , :n =>4 , :s =>0 , :p =>0, :se =>0 },
-        'N' => { :c =>4, :h =>8 , :o =>3 , :n =>2 , :s =>0 , :p =>0, :se =>0 },
-        'D' => { :c =>4, :h =>7 , :o =>4 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
-        'C' => { :c =>3, :h =>7 , :o =>2 , :n =>1 , :s =>1 , :p =>0, :se =>0 },
-        'E' => { :c =>5, :h =>9 , :o =>4 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
-        'Q' => { :c =>5, :h =>10 , :o =>3 , :n =>2 , :s =>0 , :p =>0, :se =>0 },
-        'G' => { :c =>2, :h =>5 , :o =>2 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
-        'H' => { :c =>6, :h =>9 , :o =>2 , :n =>3 , :s =>0 , :p =>0, :se =>0 },
-        'I' => { :c =>6, :h =>13 , :o =>2 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
-        'L' => { :c =>6, :h =>13 , :o =>2 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
-        'K' => { :c =>6, :h =>14 , :o =>2 , :n =>2 , :s =>0 , :p =>0, :se =>0 },
-        'M' => { :c =>5, :h =>11 , :o =>2 , :n =>1 , :s =>1 , :p =>0, :se =>0 },
-        'F' => { :c =>9, :h =>11 , :o =>2 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
-        'P' => { :c =>5, :h =>9 , :o =>2 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
-        'S' => { :c =>3, :h =>7 , :o =>3 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
-        'T' => { :c =>4, :h =>9 , :o =>3 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
-        'W' => { :c =>11, :h =>12 , :o =>2 , :n =>2 , :s =>0 , :p =>0, :se =>0 },
-        'Y' => { :c =>9, :h =>11 , :o =>3 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
-        'V' => { :c =>5, :h =>11 , :o =>2 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
-        'U' => { :c =>3, :h =>7 , :o =>2 , :n =>1 , :s =>0 , :p =>0, :se =>1 },
-        'O' => { :c =>12, :h =>21 , :o =>3 , :n =>3 , :s =>0 , :p =>0, :se =>0 }
+        'A' => { :c =>3, :h =>5 , :o =>1 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
+        'R' => { :c =>6, :h =>12 , :o =>1 , :n =>4 , :s =>0 , :p =>0, :se =>0 },
+        'N' => { :c =>4, :h =>6 , :o =>2 , :n =>2 , :s =>0 , :p =>0, :se =>0 },
+        'D' => { :c =>4, :h =>5 , :o =>3 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
+        'C' => { :c =>3, :h =>5 , :o =>1 , :n =>1 , :s =>1 , :p =>0, :se =>0 },
+        'E' => { :c =>5, :h =>7 , :o =>3 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
+        'Q' => { :c =>5, :h =>8 , :o =>2 , :n =>2 , :s =>0 , :p =>0, :se =>0 },
+        'G' => { :c =>2, :h =>3 , :o =>1 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
+        'H' => { :c =>6, :h =>7 , :o =>1 , :n =>3 , :s =>0 , :p =>0, :se =>0 },
+        'I' => { :c =>6, :h =>11 , :o =>1 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
+        'L' => { :c =>6, :h =>11 , :o =>1 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
+        'K' => { :c =>6, :h =>12 , :o =>1 , :n =>2 , :s =>0 , :p =>0, :se =>0 },
+        'M' => { :c =>5, :h =>9 , :o =>1 , :n =>1 , :s =>1 , :p =>0, :se =>0 },
+        'F' => { :c =>9, :h =>9 , :o =>1 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
+        'P' => { :c =>5, :h =>7 , :o =>1 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
+        'S' => { :c =>3, :h =>5 , :o =>2 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
+        'T' => { :c =>4, :h =>7 , :o =>2 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
+        'W' => { :c =>11, :h =>10 , :o =>1 , :n =>2 , :s =>0 , :p =>0, :se =>0 },
+        'Y' => { :c =>9, :h =>9 , :o =>2 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
+        'V' => { :c =>5, :h =>9 , :o =>1 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
+        'U' => { :c =>3, :h =>5 , :o =>1 , :n =>1 , :s =>0 , :p =>0, :se =>1 },
+        'O' => { :c =>12, :h =>19 , :o =>2 , :n =>3 , :s =>0 , :p =>0, :se =>0 }
       }
-      ATOM_COUNTS_SYM = {
-        :A => { :c =>3, :h =>7 , :o =>2 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
-        :R => { :c =>6, :h =>14 , :o =>2 , :n =>4 , :s =>0 , :p =>0, :se =>0 },
-        :N => { :c =>4, :h =>8 , :o =>3 , :n =>2 , :s =>0 , :p =>0, :se =>0 },
-        :D => { :c =>4, :h =>7 , :o =>4 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
-        :C => { :c =>3, :h =>7 , :o =>2 , :n =>1 , :s =>1 , :p =>0, :se =>0 },
-        :E => { :c =>5, :h =>9 , :o =>4 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
-        :Q => { :c =>5, :h =>10 , :o =>3 , :n =>2 , :s =>0 , :p =>0, :se =>0 },
-        :G => { :c =>2, :h =>5 , :o =>2 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
-        :H => { :c =>6, :h =>9 , :o =>2 , :n =>3 , :s =>0 , :p =>0, :se =>0 },
-        :I => { :c =>6, :h =>13 , :o =>2 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
-        :L => { :c =>6, :h =>13 , :o =>2 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
-        :K => { :c =>6, :h =>14 , :o =>2 , :n =>2 , :s =>0 , :p =>0, :se =>0 },
-        :M => { :c =>5, :h =>11 , :o =>2 , :n =>1 , :s =>1 , :p =>0, :se =>0 },
-        :F => { :c =>9, :h =>11 , :o =>2 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
-        :P => { :c =>5, :h =>9 , :o =>2 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
-        :S => { :c =>3, :h =>7 , :o =>3 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
-        :T => { :c =>4, :h =>9 , :o =>3 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
-        :W => { :c =>11, :h =>12 , :o =>2 , :n =>2 , :s =>0 , :p =>0, :se =>0 },
-        :Y => { :c =>9, :h =>11 , :o =>3 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
-        :V => { :c =>5, :h =>11 , :o =>2 , :n =>1 , :s =>0 , :p =>0, :se =>0 },
-        :U => { :c =>3, :h =>7 , :o =>2 , :n =>1 , :s =>0 , :p =>0, :se =>1 },
-        :O => { :c =>12, :h =>21 , :o =>3 , :n =>3 , :s =>0 , :p =>0, :se =>0 }
-      }
-      ATOM_COUNTS_STR.each {|aa,val| ATOM_COUNTS[aa.to_sym] = val }
+      ATOM_COUNTS_SYM = Hash[ATOM_COUNTS_STR.map {|k,v| [k.to_sym, v] }]
 
       # string and symbol access of amino acid (atoms are all lower case
       # symbols)

data/lib/ms/mass.rb

@@ -2,7 +2,7 @@
 module MS
   module Mass
 
-    # takes a chemical formula in this format: C2BrH12O
+    # takes a molecular formula in this format: C2BrH12O
     def self.formula_to_exact_mass(formula)
       # TODO: add other input methods
       pairs = formula.scan(/([A-Z][a-z]?)(\d*)/).map do |match|

data/lib/ms/mzml.rb

@@ -10,7 +10,7 @@ module MS
   #         scan = spectrum.scan
   #         spectrum.mzs                  # array of m/zs
   #         spectrum.intensities          # array of intensities
-  #         spectrum.peaks.each do |mz,intensity|
+  #         spectrum.points.each do |mz,intensity|
   #           puts "mz: #{mz} intensity: #{intensity}" 
   #         end
   #       end

data/lib/ms/peak/point.rb

@@ -0,0 +1,13 @@
+
+module MS
+  class Peak
+    # A point is typically a doublet: an x value and a y value.  In a spectrum
+    # this will be an m/z and intensity.  In a chromatogram this will be a
+    # retention time and an intensity.  (This class can be subclassed if
+    # desired)
+    class Point < Array
+      alias_method :x, :first
+      alias_method :y, :last
+    end
+  end
+end

data/lib/ms/peak.rb

@@ -0,0 +1,108 @@
+
+module MS ; end
+# an MS::Peak instance is an array of contiguous points (where each point is
+# a doublet: an x coordinate and a y coordinate)
+class MS::Peak < Array
+
+  # returns an Array of peaks.  Splits peak with 1 or more local minima into
+  # multiple peaks.  When a point is 'shared' between two adjacent peak-ish
+  # areas, the choice of how to resolve multi-peaks (runs of data above
+  # zero) is one of:
+  #
+  #     false/nil => only split on zeros
+  #     :share => give each peak its rightful portion of shared peaks, dividing the
+  #               intensity based on the intensity of adjacent peaks
+  #     :greedy_y => give the point to the peak with highest point next to
+  #                  the point in question. tie goes lower.
+  #
+  # if return_local_minima is true, a parallel array of local minima indices is
+  # returned (only makes sense if split_multipeaks is false)
+  # 
+  # assumes that a new point can be made with an array containing the x
+  # value and the y value.
+  def split(split_multipeaks=false, return_local_minima=false)
+    if split_multipeaks
+      (zeroed_peaks, local_min_ind_ar) = self.split(false, true)
+      $stderr.print "splitting on local minima ..." if $VERBOSE
+      no_local_minima_peaks = zeroed_peaks.zip(local_min_ind_ar).map do |peak, lm_indices|
+        new_peaks = [ peak.class.new ]
+        if lm_indices.size > 0
+          prev_lm_i = -1   # <- it's okay, we don't use until it is zero
+          lm_indices.each do |lm_i|
+            lm = peak[lm_i]
+            point_class = lm.class
+
+            # push onto the last peak all the points from right after the previous local min
+            # to just before this local min
+            new_peaks.last.push( *peak[(prev_lm_i+1)..(lm_i-1)] )
+            before_pnt = peak[lm_i-1]
+            after_pnt = peak[lm_i+1]
+
+            case split_multipeaks
+            when :share
+              sum = before_pnt[1] + after_pnt[1]
+              # push onto the last peak its portion of the local min
+              new_peaks.last << point_class.new( [lm[0], lm[1] * (before_pnt[1].to_f/sum)] )
+              # create a new peak that contains its portion of the local min
+              new_peaks << self.class.new( [point_class.new([lm[0], lm[1] * (after_pnt[1].to_f/sum)])] )
+              prev_lm_i = lm_i
+            when :greedy_y
+              if before_pnt[1] >= after_pnt[1]
+                new_peaks.last << lm
+                new_peaks << self.class.new
+                prev_lm_i = lm_i
+              else
+                new_peaks << self.class.new( [lm] )
+                prev_lm_i = lm_i
+              end
+            else
+              raise ArgumentError, "only recognize :share, :greedy_y, or false for the arg in #split(arg)"
+            end
+          end
+          new_peaks.last.push( *peak[(prev_lm_i+1)...peak.size] )
+          new_peaks
+        else
+          [peak]
+        end
+      end.flatten(1) # end zip
+      $stderr.puts "now #{no_local_minima_peaks.size} peaks." if $VERBOSE
+      no_local_minima_peaks 
+    else
+      $stderr.print "splitting on zeros..." if $VERBOSE
+      # first, split the peaks based on zero intensity values 
+      # and simultaneously keep track of the local minima within each
+      # resulting peak
+      peaks = []
+      local_min_ind_ar = []
+      in_peak = false
+      self.each_with_index do |point, index|
+        previous_y = self[index - 1][1]
+        if point[1] > 0
+          if !in_peak
+            in_peak = 0
+            peaks << self.class.new([point])
+            local_min_ind_ar << []
+          else
+            peaks.last << point
+            # if on_upslope(previous_y, point[1])
+            if previous_y < point[1]
+              # If we were previously on a downslope and we are now on an upslope
+              # then the previous index is a local min
+              prev_previous_y = self[index - 2][1]
+              # on_downslope(prev_previous_y, previous_y)
+              if prev_previous_y > previous_y
+                # We have found a local min
+                local_min_ind_ar.last << (in_peak-1)
+              end
+            end # end if (upslope)
+          end # end if !in_peak
+          in_peak += 1
+        elsif in_peak
+          in_peak = false
+        end # end if point[1] > 0
+      end
+      $stderr.puts "#{peaks.size} no-whitespace-inside peaks." if $VERBOSE
+      return_local_minima ? [peaks, local_min_ind_ar] : peaks
+    end # 
+  end # def split
+end

data/lib/ms/spectrum/centroid.rb

@@ -0,0 +1,17 @@
+
+module MS
+  class Spectrum
+    # this module can be used to extend the behavior of some peaks as desired
+    module Centroidish
+      def mz() first end
+      def intensity() last end
+    end
+    # an Array implementation of Centroidish using alias_method.  Accessing
+    # :mz and :intensity using this object will be nearly 2X as fast as
+    # extending the Centroidish behavior (confirmed by testing)
+    class Centroid < Array
+      alias_method :mz, :first
+      alias_method :intensity, :last
+    end
+  end
+end

data/lib/ms/spectrum.rb

@@ -1,21 +1,180 @@
 require 'bsearch'
+require 'bin'
+require 'ms/peak'
 
 module MS
+  # note that a point is an [m/z, intensity] doublet.
+  # A peak is considered a related string of points
   class Spectrum
     include Enumerable
 
+    DEFAULT_MERGE = {
+      :bin_width => 5,
+      :bin_unit => :ppm,
+      :normalize => true,
+      :return_data => false,
+      :split => :share
+    }
+
+    # returns a new spectrum which has been merged with the others.  If the
+    # spectra are centroided (just checks the first one and assumes the others
+    # are the same) then it will bin the points (bin width determined by
+    # opts[:resolution]) and then segment according to monotonicity (sharing
+    # intensity between abutting points).  The  final m/z is the weighted
+    # averaged of all the m/z's in each peak.  Valid opts (with default listed
+    # first):
+    #
+    #     :bin_width => 5 
+    #     :bin_unit => :ppm | :amu        interpret bin_width as ppm or amu
+    #     :bins => array of Bin objects   for custom bins (overides other bin options)
+    #     :normalize => false             if true, divides total intensity by 
+    #                                     number of spectra
+    #     :return_data => false           returns a parallel array containing
+    #                                     the peaks associated with each returned point
+    #     :split => :share | :greedy_y    see MS::Peak#split
+    #
+    # The binning algorithm is the fastest possible algorithm that would allow
+    # for arbitrary, non-constant bin widths (a ratcheting algorithm O(n + m))
+    def self.merge(spectra, opts={})
+      opt = DEFAULT_MERGE.merge(opts)
+      (spectrum, returned_data) =  
+        if spectra.first.centroided?
+          # find the min and max across all spectra
+          first_mzs = spectra.first.mzs
+          min = first_mzs.first ; max = first_mzs.last
+          spectra.each do |spectrum| 
+            mzs = spectrum.mzs
+            min = mzs.first if mzs.first < min
+            max = mzs.last if mzs.last > max
+          end
+
+          # Create Bin objects
+          bins = 
+            if opt[:bins]
+              opt[:bins]
+            else
+              divisions = []
+              bin_width = opt[:bin_width]
+              use_ppm = (opt[:bin_unit] == :ppm)
+              current_mz = min
+              loop do
+                if current_mz >= max
+                  divisions << max
+                  break
+                else
+                  divisions << current_mz
+                  current_mz += ( use_ppm ? current_mz./(1e6).*(bin_width) : bin_width )
+                end
+              end
+              # make each bin exclusive so there is no overlap
+              bins = divisions.each_cons(2).map {|pair| Bin.new(*pair, true) }
+              # make the last bin *inclusive* of the terminating value
+              bins[-1] = Bin.new(bins.last.begin, bins.last.end)
+              bins
+            end
+
+          spectra.each do |spectrum|
+            Bin.bin(bins, spectrum.points, &:first)
+          end
+
+          pseudo_points = bins.map do |bin|
+            #int = bin.data.reduce(0.0) {|sum,point| sum + point.last }.round(3)   # <- just for info:
+            [bin, bin.data.reduce(0.0) {|sum,point| sum + point.last }]
+          end
+
+          #p_mzs = [] 
+          #p_ints = [] 
+          #p_num_points = [] 
+          #pseudo_points.each do |psp|
+          #  p_mzs << ((psp.first.begin + psp.first.end)/2)
+          #  p_ints << psp.last
+          #  p_num_points <<  psp.first.data.size
+          #end
+
+          #File.write("file_#{opt[:bin_width]}_to_plot.txt", [p_mzs, p_ints, p_num_points].map {|ar| ar.join(' ') }.join("\n"))
+          #abort 'here'
+
+
+          peaks = MS::Peak.new(pseudo_points).split(opt[:split])
+
+          return_data = []
+          _mzs = [] ; _ints = []
+
+          #p peaks[97]
+          #puts "HIYA"
+          #abort 'here'
+
+          peaks.each_with_index do |peak,i|
+          #peaks.each do |peak|
+            tot_intensity = peak.map(&:last).reduce(:+)
+            return_data_per_peak = [] if opt[:return_data]
+            weighted_mz = 0.0
+            peak.each do |point|
+              pre_scaled_intensity = point[0].data.reduce(0.0) {|sum,v| sum + v.last }
+              post_scaled_intensity = point[1]
+              # some peaks may have been shared.  In this case the intensity
+              # for that peak was downweighted.  However, the actually data
+              # composing that peak is not altered when the intensity is
+              # shared.  So, to calculate a proper weighted avg we need to
+              # downweight the intensity of any data point found within a bin
+              # whose intensity was scaled.
+              correction_factor = 
+                if pre_scaled_intensity != post_scaled_intensity
+                  post_scaled_intensity / pre_scaled_intensity
+                else
+                  1.0
+                end
+
+              return_data_per_peak.push(*point[0].data) if opt[:return_data]
+
+              point[0].data.each do |lil_point|
+                weighted_mz += lil_point[0] * ( (lil_point[1].to_f * correction_factor) / tot_intensity)
+              end
+            end
+            return_data << return_data_per_peak if opt[:return_data]
+            _mzs << weighted_mz
+            _ints << tot_intensity
+          end
+          [Spectrum.new([_mzs, _ints]), return_data]
+        else
+          raise NotImplementedError, "the way to do this is interpolate the profile evenly and sum"
+        end
+
+      if opt[:normalize]
+        sz = spectra.size
+        spectrum.data[1].map! {|v| v.to_f / sz }
+      end
+      if opt[:return_data]
+        $stderr.puts "returning spectrum (#{spectrum.mzs.size}) and data" if $VERBOSE
+        [spectrum, return_data]
+      else
+        $stderr.puts "returning spectrum (#{spectrum.mzs.size})" if $VERBOSE
+        spectrum
+      end
+    end
+
+
+    # boolean for if the spectrum represents centroided data or not
+    attr_accessor :centroided
+
+    def centroided?() centroided end
+
     # The underlying data store. methods are implemented so that data[0] is
     # the m/z's and data[1] is intensities
     attr_reader :data
     
+
+
+
     # data takes an array: [mzs, intensities]
     # @return [MS::Spectrum]
     # @param [Array] data two element array of mzs and intensities
-    def initialize(data)
+    def initialize(data, centroided=true)
       @data = data
+      @centroided = centroided
     end
 
-    def self.from_peaks(ar_of_doublets)
+    def self.from_points(ar_of_doublets)
       _mzs = []
       _ints = []
       ar_of_doublets.each do |mz, int|
@@ -55,12 +214,12 @@ module MS
     end
 
     # yields(mz, inten) across the spectrum, or array of doublets if no block
-    def peaks(&block)
+    def points(&block)
       @data[0].zip(@data[1], &block)
     end
 
-    alias_method :each, :peaks
-    alias_method :each_peak, :peaks
+    alias_method :each, :points
+    alias_method :each_point, :points
 
     # if the mzs and intensities are the same then the spectra are considered
     # equal
@@ -83,9 +242,9 @@ module MS
     # instruments are bad about this)
     # returns self
     def sort!
-      _peaks = peaks.to_a
-      _peaks.sort!
-      _peaks.each_with_index {|(mz,int), i| @data[0][i] = mz ; @data[1][i] = int }
+      _points = points.to_a
+      _points.sort!
+      _points.each_with_index {|(mz,int), i| @data[0][i] = mz ; @data[1][i] = int }
       self
     end
 
@@ -95,7 +254,7 @@ module MS
       mzs[find_nearest_index(val)]
     end
 
-    # same as find_nearest but returns the index of the peak
+    # same as find_nearest but returns the index of the point
     def find_nearest_index(val)
       find_all_nearest_index(val).first
     end
@@ -126,6 +285,12 @@ module MS
       find_all_nearest_index(val).map {|i| mzs[i] }
     end
 
+    # uses MS::Spectrum.merge
+    def merge(other_spectra, opts={})
+      MS::Spectrum.merge([self, *other_spectra], opts)
+    end
+
+
   end
 end
 

data/spec/bin_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+require 'bin'
+
+describe Bin do
+
+  describe 'putting data into bins' do
+
+    def matching(bins, peaks, bin_to_peak_index_pairs)
+      bins_dup = bins.dup
+      bin_to_peak_index_pairs.sort_by(&:first).reverse.each do |bin_i, peak_i|
+        _bin = bins_dup.delete_at(bin_i)
+        data = _bin.respond_to?(:data) ? _bin.data[0] : _bin[0]
+        data.should == peaks[peak_i]
+      end
+      bins_dup.map! {|bin| bin.respond_to?(:data) ? bin.data : bin }
+      bins_dup.all? {|bin| bin.size == 0 }.should be_true
+    end
+
+    def self.make_ranges(range, use_bin=false)
+      klass = use_bin ? Bin : Range
+      range.map {|i| klass.new(i.to_f, (i+1).to_f, true) }
+    end
+
+    def self.make_pairs(x_vals)
+      x_vals.each_with_index.map {|v,i| [v, i*100] }
+    end
+
+    def ranges_to_bins(ranges)
+      ranges.map {|range| Bin.new(range.begin, range.end, true) }
+    end
+
+    data = {
+      lower_and_lower: {
+      range: 0..9,
+      peaks: [3.0, 4.4, 11.0],
+      bin_to_peak_index_pairs: [[3,0], [4,1]]
+    },
+      higher_and_higher: {
+      range: 3..9,
+      peaks: [1.0, 2.99, 5.2],
+      bin_to_peak_index_pairs: [[2,2]]
+    },
+      lower_and_higher: {
+      range: 3..11,
+      peaks: [5.2, 11.0],
+      bin_to_peak_index_pairs: [[2,0], [8,1]]
+    },
+      higher_and_lower: {
+      range: 2..9,
+      peaks: [1.0, 2.99, 5.2, 11.0],
+      bin_to_peak_index_pairs: [[0,1],[3,2]]
+    }
+    }
+    data = data.map do |key, hash|
+      [ key, { ranges: make_ranges(hash[:range]),
+        peaks: make_pairs(hash[:peaks]),
+        bin_to_peak_index_pairs: hash[:bin_to_peak_index_pairs]} ]
+    end
+    data = Hash[data]
+    # not really the subject, but it is the data we care about here...
+
+    data.each do |type, init|
+      it "works for bins to data #{type.to_s.gsub('_',' ')}" do
+        rbins = Bin.bin(ranges_to_bins(init[:ranges]), init[:peaks], &:first)
+        matching(rbins, init[:peaks], init[:bin_to_peak_index_pairs])
+      end
+    end
+
+    data.each do |type, init|
+      it "works for ranges to data #{type.to_s.gsub('_',' ')}" do
+        custom_data_store = (0...init[:ranges].size).map { [] }
+        rbins = Bin.bin(init[:ranges], init[:peaks], custom_data_store, &:first)
+        matching(rbins, init[:peaks], init[:bin_to_peak_index_pairs])
+      end
+    end
+  end
+end

data/spec/ms/isotope/aa_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+require 'ms/isotope/aa'
+
+describe 'accessing an amino acid atom count' do
+  before do
+    @alanine = {:c=>3, :h=>5, :o=>1, :n=>1, :s=>0, :p=>0, :se=>0}
+  end
+
+  it 'residue can be accessed with a symbol' do
+    hash = MS::Isotope::AA::ATOM_COUNTS[:A]
+    [:c, :h, :o, :n, :s].each {|key| hash[key].should == @alanine[key] }
+  end
+    
+  it 'residue can be accessed with a string' do
+    hash = MS::Isotope::AA::ATOM_COUNTS['A']
+    [:c, :h, :o, :n, :s].each {|key| hash[key].should == @alanine[key] }
+  end
+
+end

data/spec/ms/peak_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+require 'ms/peak'
+require 'ms/peak/point'
+
+describe MS::Peak do
+
+  describe '#split' do
+
+    before do
+      # xs could be m/z values or retention times
+      simple = [ 0, 3, 8, 9, 7, 2, 0 ]
+      multi_large1 = [ 0, 3, 8, 2, 9, 7, 1, 3, 0 ]
+      multi_large2 = [ 0, 10, 8, 2, 9, 7, 1, 3, 0 ]
+      doublet = [ 0, 10, 8, 0 ]
+
+      start_mz = 50
+      @intensities = simple + multi_large1 + multi_large2 + doublet
+      @xs = []
+      mz = start_mz
+      diff = 0.01
+      loop do
+        @xs << mz
+        break if @xs.size == @intensities.size
+        mz += diff
+      end
+      @xs.map! {|mz| mz.round(2) }
+      @points = @xs.zip(@intensities).map {|pair| MS::Peak::Point.new(pair) }
+    end
+
+    it 'splits on zeros by default' do
+      peak = MS::Peak.new(@points) # <- maybe more like a collection of peaks, but Peak is flexible
+      peaks = peak.split
+      peaks.size.should == 4
+      peaks.should == [
+        [[50.01, 3], [50.02, 8], [50.03, 9], [50.04, 7], [50.05, 2]],
+        [[50.08, 3], [50.09, 8], [50.1, 2], [50.11, 9], [50.12, 7], [50.13, 1], [50.14, 3]],
+        [[50.17, 10], [50.18, 8], [50.19, 2], [50.2, 9], [50.21, 7], [50.22, 1], [50.23, 3]],
+        [[50.26, 10], [50.27, 8]]
+      ]
+      # returns local minima if asked
+      (peaks2, local_minima) = peak.split(false, true)
+      peaks2.should == peaks
+      local_minima.should == [[], [2, 5], [2, 5], []]
+    end
+
+    # which it should since zeros are the ultimate local min!
+    it 'always cleans up surrounding zeros and does not split non-multipeaks' do
+      peak = MS::Peak.new(@points[0,7])  # simple
+      [:share, :greedy_y].each do |multipeak_split_method|
+        peaks = peak.split(multipeak_split_method)
+        peaks.first.should be_an_instance_of(MS::Peak)
+        peaks.first.to_a.should == [[50.01, 3], [50.02, 8], [50.03, 9], [50.04, 7], [50.05, 2]]
+      end
+    end
+
+    it 'does #split(:share) and shares the peak proportional to adjacent peaks' do
+      data = [[50.07, 0], [50.08, 3], [50.09, 8], [50.1, 2], [50.11, 9], [50.12, 7], [50.13, 1], [50.14, 3], [50.15, 0]]
+      multipeak1 = MS::Peak.new( data )
+
+      answer = [
+        [[50.08, 3], [50.09, 8], [50.1, (2*8.0/17)]], 
+        [[50.1, 2*9.0/17], [50.11, 9], [50.12, 7], [50.13, 0.7]],
+        [[50.13, 0.3], [50.14, 3]]
+      ]
+      multipeak1.split(:share).should == answer
+
+      answer = [
+        [[50.08, 3], [50.09, 8]], 
+        [[50.1, 2], [50.11, 9], [50.12, 7], [50.13, 1]], 
+        [[50.14, 3]]
+      ]
+      multipeak1.split(:greedy_y).should == answer
+
+      answer = [
+        [[50.08, 3], [50.09, 9], [50.1, 2]], 
+        [[50.11, 9], [50.12, 7], [50.13, 1]], 
+        [[50.14, 3]]
+      ] 
+
+      # test a tie -> goes left!
+      points = @points[7,9]
+      points[2] = MS::Peak::Point.new([points[2][0], 9])
+      multipeak2 = MS::Peak.new( points )
+      multipeak2.split(:greedy_y).should == answer
+
+    end
+  end
+
+end

data/spec/ms/spectrum_spec.rb

@@ -45,4 +45,21 @@ describe MS::Spectrum do
     end
   end
 
+  describe 'merging spectra' do
+    subject do  
+      data = [ [10.10, 10.5, 10.7, 11.5], [1, 2, 3, 4] ],
+        [ [10.11, 10.49, 10.71, 11.48], [5, 6, 7, 8] ],
+        [ [10.09, 10.51, 10.72, 11.51], [9, 10, 11, 12] 
+      ]
+      data.map {|datum| MS::Spectrum.new( datum ) }
+    end
+    it 'merges, giving exact weighted average m/z values for each cluster' do
+      (spec1, data) = MS::Spectrum.merge(subject, :bin_width => 0.08, :bin_unit => :amu, :return_data => true)
+      spec2 = MS::Spectrum.merge(subject, :bin_width => 0.08, :bin_unit => :amu)
+      spec1.should == spec2
+      spec1.should == MS::Spectrum.new([[10.097333333333331, 10.502222222222223, 10.713809523809525, 11.498333333333333], [5.0, 6.0, 7.0, 8.0]])
+      data.should == [[[10.1, 1], [10.11, 5], [10.09, 9]], [[10.5, 2], [10.49, 6], [10.51, 10]], [[10.7, 3], [10.71, 7], [10.72, 11]], [[11.5, 4], [11.48, 8], [11.51, 12]]] 
+    end
+  end
+
 end

metadata

@@ -1,96 +1,111 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: mspire
-version: !ruby/object:Gem::Version
-  version: 0.6.2
+version: !ruby/object:Gem::Version 
   prerelease: 
+  version: 0.6.6
 platform: ruby
-authors:
+authors: 
 - John T. Prince
 - Simon Chiang
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-02 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2012-02-13 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: nokogiri
-  requirement: &8784820 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
+    requirements: 
     - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.5'
+      - !ruby/object:Gem::Version 
+        version: "1.5"
   type: :runtime
-  prerelease: false
-  version_requirements: *8784820
-- !ruby/object:Gem::Dependency
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
   name: bsearch
-  requirement: &8782400 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
         version: 1.5.0
   type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: andand
   prerelease: false
-  version_requirements: *8782400
-- !ruby/object:Gem::Dependency
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.3.1
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
   name: obo
-  requirement: &8781260 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
         version: 0.1.0
   type: :runtime
-  prerelease: false
-  version_requirements: *8781260
-- !ruby/object:Gem::Dependency
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
   name: rspec
-  requirement: &8780220 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
+    requirements: 
     - - ~>
-      - !ruby/object:Gem::Version
-        version: '2.6'
+      - !ruby/object:Gem::Version 
+        version: "2.6"
   type: :development
-  prerelease: false
-  version_requirements: *8780220
-- !ruby/object:Gem::Dependency
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
   name: jeweler
-  requirement: &8795440 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
+    requirements: 
     - - ~>
-      - !ruby/object:Gem::Version
+      - !ruby/object:Gem::Version 
         version: 1.5.2
   type: :development
-  prerelease: false
-  version_requirements: *8795440
-- !ruby/object:Gem::Dependency
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
   name: rcov
-  requirement: &8792600 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
   type: :development
-  prerelease: false
-  version_requirements: *8792600
-description: mass spectrometry proteomics, lipidomics, and tools, a rewrite of mspire,
-  merging of ms-* gems
+  version_requirements: *id007
+description: mass spectrometry proteomics, lipidomics, and tools, a rewrite of mspire, merging of ms-* gems
 email: jtprince@gmail.com
 executables: []
+
 extensions: []
-extra_rdoc_files:
+
+extra_rdoc_files: 
 - LICENSE
 - README.rdoc
-files:
+files: 
 - LICENSE
 - README.rdoc
 - Rakefile
 - VERSION
+- lib/bin.rb
+- lib/core_ext/array/in_groups.rb
 - lib/cv.rb
 - lib/cv/description.rb
 - lib/cv/param.rb
@@ -128,10 +143,13 @@ files:
 - lib/ms/mzml/index_list.rb
 - lib/ms/mzml/plms1.rb
 - lib/ms/obo.rb
+- lib/ms/peak.rb
+- lib/ms/peak/point.rb
 - lib/ms/plms1.rb
 - lib/ms/quant/qspec.rb
 - lib/ms/quant/qspec/protein_group_comparison.rb
 - lib/ms/spectrum.rb
+- lib/ms/spectrum/centroid.rb
 - lib/msplat.rb
 - lib/obo/ims.rb
 - lib/obo/ms.rb
@@ -142,6 +160,7 @@ files:
 - obo/ims.obo
 - obo/ms.obo
 - obo/unit.obo
+- spec/bin_spec.rb
 - spec/ms/cvlist_spec.rb
 - spec/ms/digester_spec.rb
 - spec/ms/fasta_spec.rb
@@ -150,10 +169,12 @@ files:
 - spec/ms/ident/pepxml/search_hit/modification_info_spec.rb
 - spec/ms/ident/pepxml_spec.rb
 - spec/ms/ident/protein_group_spec.rb
+- spec/ms/isotope/aa_spec.rb
 - spec/ms/mass_spec.rb
 - spec/ms/mzml/index_list_spec.rb
 - spec/ms/mzml/plms1_spec.rb
 - spec/ms/mzml_spec.rb
+- spec/ms/peak_spec.rb
 - spec/ms/plms1_spec.rb
 - spec/ms/quant/qspec_spec.rb
 - spec/ms/spectrum_spec.rb
@@ -185,28 +206,31 @@ files:
 - spec/testfiles/ms/quant/unlog_transform.rb
 - spec/testfiles/plms1/output.key
 homepage: http://github.com/princelab/mspire
-licenses:
+licenses: 
 - MIT
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: mass spectrometry proteomics, lipidomics, and tools
 test_files: []
+