mspire 0.5.0 → 0.6.1

data/lib/ms/spectrum.rb

@@ -1,14 +1,35 @@
-module Ms
+module MS
   class Spectrum
+    include Enumerable
+
     # The underlying data store.
     attr_reader :data
     
-    # Associated headers
-    attr_reader :headers
-    
-    def initialize(data, headers={})
+    # data takes an array: [mzs, intensities]
+    # @return [MS::Spectrum]
+    # @param [Array] data two element array of mzs and intensities
+    def initialize(data)
       @data = data
-      @headers = headers
+    end
+
+    def self.from_peaks(ar_of_doublets)
+      _mzs = []
+      _ints = []
+      ar_of_doublets.each do |mz, int|
+        _mzs << mz
+        _ints << int
+      end
+      self.new([_mzs, _ints])
+    end
+
+    # found by querying the size of the data store.  This should almost always
+    # be 2 (m/z and intensities)
+    def size
+      @data.size
+    end
+
+    def ==(other)
+      mzs == other.mzs && intensities == other.intensities
     end
       
     # An array of the mz data.
@@ -20,6 +41,131 @@ module Ms
     def intensities
       @data[1]
     end
-    
+
+    def mzs_and_intensities
+      [@data[0], @data[1]]
+    end
+
+    # retrieve an m/z and intensity doublet at that index
+    def [](array_index)
+      [mzs[array_index], intensities[array_index]]
+    end
+
+    # yields(mz, inten) across the spectrum, or array of doublets if no block
+    def peaks(&block)
+      (m, i) = mzs_and_intensities
+      m.zip(i, &block)
+    end
+
+    alias_method :each, :peaks
+    alias_method :each_peak, :peaks
+
+    # if the mzs and intensities are the same then the spectra are considered
+    # equal
+    def ==(other)
+      mzs == other.mzs && intensities == other.intensities
+    end
+
+    # returns a new spectrum whose intensities have been normalized by the tic
+    def normalize
+      tic = self.intensities.inject(0.0) {|sum,int| sum += int }
+      MS::Spectrum.new([self.mzs, self.intensities.map {|v| v / tic }])
+    end
+
+    ## uses index function and returns the intensity at that value
+    #def intensity_at_mz(mz)
+      #if x = index(mz)
+        #intensities[x]
+      #else
+        #nil
+      #end
+    #end
+
+    ## index mz, tolerance = :nearest(1), Float, :nearest_within_integer
+
+    ## returns the index of the first value matching that m/z.  the argument m/z
+    ## may be less precise than the actual m/z (rounding to the same precision
+    ## given) but must be at least integer precision (after rounding)
+    ## implemented as binary search (bsearch from the web)
+    #def index(mz)
+      #mz_ar = mzs
+      #return_val = nil
+      #ind = mz_ar.bsearch_lower_boundary{|x| x <=> mz }
+      #if mz_ar[ind] == mz
+        #return_val = ind
+      #else 
+        ## do a rounding game to see which one is it, or nil
+        ## find all the values rounding to the same integer in the locale
+        ## test each one fully in turn
+        #mz = mz.to_f
+        #mz_size = mz_ar.size
+        #if ((ind < mz_size) and equal_after_rounding?(mz_ar[ind], mz))
+          #return_val = ind
+        #else # run the loop
+          #up = ind
+          #loop do
+            #up += 1
+            #if up >= mz_size
+              #break
+            #end
+            #mz_up = mz_ar[up]
+            #if (mz_up.ceil  - mz.ceil >= 2)
+              #break
+            #else
+              #if equal_after_rounding?(mz_up, mz)
+                #return_val = up
+                #return return_val
+              #end
+            #end
+          #end
+          #dn= ind
+          #loop do
+            #dn -= 1
+            #if dn < 0
+              #break
+            #end
+            #mz_dn = mz_ar[dn]
+            #if (mz.floor - mz_dn.floor >= 2)
+              #break
+            #else
+              #if equal_after_rounding?(mz_dn, mz)
+                #return_val = dn
+                #return return_val
+              #end
+            #end
+          #end
+        #end
+      #end
+      #return_val
+    #end
+
+    ## less_precise should be a float
+    ## precise should be a float
+    #def equal_after_rounding?(precise, less_precise) # :nodoc:
+      ## determine the precision of less_precise
+      #exp10 = precision_as_neg_int(less_precise)
+      ##puts "EXP10: #{exp10}"
+      #answ = ((precise*exp10).round == (less_precise*exp10).round)
+      ##puts "TESTING FOR EQUAL: #{precise} #{less_precise}"
+      ##puts answ
+      #(precise*exp10).round == (less_precise*exp10).round
+    #end
+
+    ## returns 1 for ones place, 10 for tenths, 100 for hundredths
+    ## to a precision exceeding 1e-6
+    #def precision_as_neg_int(float) # :nodoc:
+      #neg_exp10 = 1
+      #loop do
+        #over = float * neg_exp10
+        #rounded = over.round
+        #if (over - rounded).abs <= 1e-6
+          #break
+        #end
+        #neg_exp10 *= 10
+      #end
+      #neg_exp10
+    #end
+
+
   end
-end
+end

data/lib/ms.rb

@@ -1,10 +1,3 @@
-module Ms
-  module_function
-  
-  # def parse(format, path)
-  #   const = Tap::Env.instance.search(:formats, format)
-  #   raise ArgumentError, "unknown format: #{format}" unless const
-  #   const.constantize.parse(path)
-  # end
-
-end
+
+module MS
+end

data/lib/msplat.rb

@@ -0,0 +1,2 @@
+
+require 'ms/mass/aa' # requires ms/mass

data/lib/obo/ims.rb

@@ -0,0 +1,5 @@
+require 'obo/ontology'
+
+module Obo
+  IMS = Obo::Ontology.new(Obo::Ontology::DIR + '/ims.obo')
+end

data/lib/obo/ms.rb

@@ -0,0 +1,7 @@
+require 'obo/ontology'
+
+module Obo
+  MS = Obo::Ontology.new(Obo::Ontology::DIR + '/ms.obo')
+end
+
+

data/lib/obo/ontology.rb

@@ -0,0 +1,41 @@
+require 'obo' # the gem obo
+
+module Obo
+  class Ontology
+    DIR = File.expand_path(File.dirname(__FILE__) + '/../../obo')
+    attr_accessor :header
+    attr_accessor :elements
+
+    def initialize(file_or_io)
+      obo = Obo::Parser.new(file_or_io)
+      @elements = obo.elements.to_a
+      @header = elements.shift
+    end
+    
+    # returns an id to name Hash
+    def id_to_name
+      @id_to_name ||= build_hash('id', 'name')
+    end
+    # returns a name to id Hash
+    def name_to_id
+      @name_to_id ||= build_hash('name', 'id')
+    end
+    def id_to_element
+      @id_to_element ||= build_hash('id', nil)
+    end
+
+    protected
+    def build_hash(key,val)
+      hash = {}
+      @elements.each do |el| 
+        tv = el.tagvalues
+        if val.nil?
+          hash[tv[key].first] = el
+        else
+          hash[tv[key].first] = tv[val].first
+        end
+      end
+      hash
+    end
+  end
+end

data/lib/obo/unit.rb

@@ -0,0 +1,5 @@
+require 'obo/ontology'
+
+module Obo
+  Unit = Obo::Ontology.new(Obo::Ontology::DIR + '/unit.obo')
+end

data/lib/openany.rb

@@ -0,0 +1,23 @@
+
+# takes a filename or an io object, hands a rewinded io object to the
+# reciever and then closes the file or places the io in the original
+# position.
+def openany(arg, &block)
+  io = 
+    if arg.is_a?(String)  # filename
+      File.open(arg)
+    else
+      orig_pos = arg.pos
+      arg.rewind
+      arg
+    end
+  reply = block.call(io)
+  if arg.is_a?(String)  # filename
+    io.close
+  else
+    arg.pos = orig_pos
+  end
+  reply
+end
+
+

data/lib/write_file_or_string.rb

@@ -0,0 +1,18 @@
+
+# if given a filename, writes to the file (and returns the filename),
+# otherwise, writes to a string. Yields an io object to write to.
+def write_file_or_string(filename=nil, &block)
+  out = 
+    if filename
+      File.open(filename,'w')
+    else
+      StringIO.new
+    end
+  block.call(out)
+  if filename
+    out.close
+    filename
+  else
+    out.string
+  end
+end