mspire 0.5.0 → 0.6.1

data/lib/ms/data/simple.rb

@@ -1,59 +0,0 @@
-module Ms
-  module Data
-    module_function
-    
-    # Initializes a new simple data array.
-    def new_simple(unresolved_data)
-      Simple.new(unresolved_data)
-    end
-    
-    # A Simple data array that lazily evaluates unresolved_data, and
-    # each member of unresolved_data using to_a:
-    # 
-    #   class LazyObject
-    #     attr_reader :to_a
-    #     def initialize(array)
-    #       @to_a = array
-    #     end
-    #   end
-    #
-    #   a = LazyObject.new([1,2,3])
-    #   b = LazyObject.new([4,5,6])
-    #   s = Ms::Data::Simple.new([a, b])
-    #
-    #   s.unresolved_data     # => [a, b]
-    #   s.data                # => []
-    #   s[0]                  # => [1,2,3]
-    #   s[1]                  # => [4,5,6]
-    #   s.data                # => [[1,2,3], [4,5,6]]
-    #
-    class Simple
-      # The underlying resolved data store.
-      attr_reader :data
-      
-      # The underlying unresolved data store.
-      attr_reader :unresolved_data
-      
-      def initialize(unresolved_data)
-        @data = []
-        @unresolved_data = unresolved_data
-      end
-      
-      def [](index)
-        @data[index] ||= @unresolved_data.to_a[index].to_a 
-      end
-      
-      def resolve
-        0.upto(@unresolved_data.length - 1) do |index| 
-          self[index]
-        end unless resolved?
-        
-        self
-      end
-      
-      def resolved?
-        @data.compact.length == @unresolved_data.length
-      end
-    end
-  end
-end

data/lib/ms/data/transposed.rb

@@ -1,41 +0,0 @@
-require 'ms/data/simple'
-
-module Ms
-  module Data
-    module_function
-    
-    # Initializes a new transposed data array.
-    def new_transposed(unresolved_data)
-      Transposed.new(unresolved_data)
-    end
-    
-    # A Transposed data array lazily evaluates it's unresolved data as 
-    # a transposed array.  The unresolved data is evaluated 
-    # into an array using to_a.
-    # 
-    #   t = Ms::Data::Transposed.new([[1,4],[2,5],[3,6]])
-    # 
-    #   t.unresolved_data  # => [[1,4],[2,5],[3,6]]
-    #   t.data             # => []
-    #   t[0]               # => [1,2,3]
-    #   t[1]               # => [4,5,6]
-    #   t.data             # => [[1,2,3], [4,5,6]]
-    #
-    class Transposed < Simple
-      
-      def [](index)
-        resolve.data[index]
-      end
-      
-      def resolved?
-        !@data.empty?
-      end
-      
-      def resolve
-        @data = @unresolved_data.to_a.transpose unless resolved?
-        self
-      end
-      
-    end
-  end
-end

data/lib/ms/data.rb

@@ -1,57 +0,0 @@
-require 'ms/data/interleaved'
-require 'ms/data/transposed'
-
-module Ms
-  
-  # The Data module contains a number of classes providing a standard way to
-  # resolve various data storage formats into a 'simple' data array.
-  #   
-  #   type               format
-  #   simple             [[mzs,...], [intensities...]]
-  #   transposed         [[mz,intensity], [mz,intensity], ...]
-  #   interleaved        [mz,intensity,mz,intensity,...]
-  #
-  # For instance:
-  #
-  #   s = Data.new([[1,2,3], [4,5,6]], :simple)
-  #   s.resolve.data        # => [[1,2,3], [4,5,6]]
-  #
-  #   t = Data.new([[1,4],[2,5],[3,6]], :transposed)
-  #   t.resolve.data        # => [[1,2,3], [4,5,6]]
-  #
-  #   i = Data.new([1,4,2,5,3,6], :interleaved)
-  #   i.resolve.data        # => [[1,2,3], [4,5,6]]
-  #
-  # Data is always resolved by calling to_a on the unresolved data object
-  # and then rearranging as needed (in the case of simple data, to_a is
-  # also called on each member of the unresolved data array).  This lazy 
-  # resolution allows the use of non-array unresolved_data objects such
-  # as Data::LazyString:
-  #
-  #   str = [[1,4,2,5,3,6].pack("g*")].pack("m")
-  #   unresolved_data = Data::LazyString.new(str)
-  #
-  #   i = Data.new(unresolved_data, :interleaved)
-  #   i.resolve.data        # => [[1,2,3], [4,5,6]]
-  #
-  # Obviously the big advantage of lazy data resolution is that Data objects
-  # may be instantiated cheaply while expensive operations like unpacking and
-  # rearrangement may be put off or not executed at all.
-  #
-  module Data
-    module_function
-    
-    # Initializes a new data array of the specified type by forwarding 
-    # data to the "new_<type>" method.
-    #
-    #   simple = Ms::Data.new([[1,2,3], [4,5,6]], :simple)
-    #   simple.class           # => Ms::Data::Simple
-    # 
-    #   interleaved = Ms::Data.new([1,4,2,5,3,6], :interleaved)
-    #   interleaved.class      # => Ms::Data::Interleaved
-    #
-    def new(data, type=:simple)
-      send("new_#{type}", data)  
-    end
-  end
-end

data/lib/ms/format/format_error.rb

@@ -1,12 +0,0 @@
-module Ms
-  module Format
-    class FormatError < Exception
-      attr_accessor :str
-      
-      def initialize(msg, str)
-        super(msg)
-        @str = str
-      end
-    end
-  end
-end

data/lib/ms/support/binary_search.rb

@@ -1,126 +0,0 @@
-module Ms
-  module Support
-    
-    # A binary search library adapted from: http://0xcc.net/ruby-bsearch/
-    # ---
-    #
-    # Ruby/Bsearch - a binary search library for Ruby.
-    #
-    # Copyright (C) 2001 Satoru Takabayashi <satoru@namazu.org>
-    #     All rights reserved.
-    #     This is free software with ABSOLUTELY NO WARRANTY.
-    #
-    # You can redistribute it and/or modify it under the terms of 
-    # the Ruby's licence.
-    #
-    # Example:
-    #
-    #  % irb -r ./bsearch.rb
-    #  >> %w(a b c c c d e f).bsearch_first {|x| x <=> "c"}
-    #  => 2
-    #  >> %w(a b c c c d e f).bsearch_last {|x| x <=> "c"}
-    #  => 4
-    #  >> %w(a b c e f).bsearch_first {|x| x <=> "c"}
-    #  => 2
-    #  >> %w(a b e f).bsearch_first {|x| x <=> "c"}
-    #  => nil
-    #  >> %w(a b e f).bsearch_last {|x| x <=> "c"}
-    #  => nil
-    #  >> %w(a b e f).bsearch_lower_boundary {|x| x <=> "c"}
-    #  => 2
-    #  >> %w(a b e f).bsearch_upper_boundary {|x| x <=> "c"}
-    #  => 2
-    #  >> %w(a b c c c d e f).bsearch_range {|x| x <=> "c"}
-    #  => 2...5
-    #  >> %w(a b c d e f).bsearch_range {|x| x <=> "c"}
-    #  => 2...3
-    #  >> %w(a b d e f).bsearch_range {|x| x <=> "c"}
-    #  => 2...2
-    # 
-    # The binary search algorithm is extracted from Jon Bentley's
-    # Programming Pearls 2nd ed. p.93
-    #
-    module BinarySearch
-      VERSION = '1.5'
-      
-      module_function
-
-      #
-      # Return the lower boundary. (inside)
-      #
-      def search_lower_boundary(array, range=nil, &block)
-        range = 0 ... array.length if range == nil
-        
-        lower  = range.first() -1
-        upper = if range.exclude_end? then range.last else range.last + 1 end
-        while lower + 1 != upper
-          mid = ((lower + upper) / 2).to_i # for working with mathn.rb (Rational)
-          if yield(array[mid]) < 0
-            lower = mid
-          else 
-            upper = mid
-          end
-        end
-        return upper
-      end
-
-      #
-      # This method searches the FIRST occurrence which satisfies a
-      # condition given by a block in binary fashion and return the 
-      # index of the first occurrence. Return nil if not found.
-      #
-      def search_first(array, range=nil, &block)
-        boundary = search_lower_boundary(array, range, &block)
-        if boundary >= array.length || yield(array[boundary]) != 0
-          return nil
-        else 
-          return boundary
-        end
-      end
-      
-      #
-      # Return the upper boundary. (outside)
-      #
-      def search_upper_boundary(array, range=nil, &block)
-        range = 0 ... array.length if range == nil
-                
-        lower  = range.first() -1
-        upper = if range.exclude_end? then range.last else range.last + 1 end
-        while lower + 1 != upper
-          mid = ((lower + upper) / 2).to_i # for working with mathn.rb (Rational)
-          if yield(array[mid]) <= 0
-            lower = mid
-          else 
-            upper = mid
-          end
-        end
-        return lower + 1 # outside of the matching range.
-      end
-
-      #
-      # This method searches the LAST occurrence which satisfies a
-      # condition given by a block in binary fashion and return the 
-      # index of the last occurrence. Return nil if not found.
-      #
-      def search_last(array, range=nil, &block)
-        # `- 1' for canceling `lower + 1' in bsearch_upper_boundary.
-        boundary = search_upper_boundary(array, range, &block) - 1
-
-        if (boundary <= -1 || yield(array[boundary]) != 0)
-          return nil
-        else
-          return boundary
-        end
-      end
-
-      #
-      # Return the search result as a Range object.
-      #
-      def search_range(array, range=nil, &block)
-        lower = search_lower_boundary(array, range, &block)
-        upper = search_upper_boundary(array, range, &block)
-        return lower ... upper
-      end
-    end
-  end
-end