binneroc 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d70ff7c6d7bfa6b7f32f6a2fa5f685f8ac1b53d5
+  data.tar.gz: f52335a79ed002f66961a5652198ff6a58c841db
+SHA512:
+  metadata.gz: b81eaa4e1c4b1236690e091b263efe898299dd226b247f98f205cc1c5131d07c48eb37f7bce8fefee504ad46a2297a54fe2a39c2738ec345cdd470ae8a8add5a
+  data.tar.gz: 327fae84a3591fedf8f0938f3e7f13cca1a5fe9b06767b36583efe890000158f2939d8a5a31bb0f088c3392da0c988d210acdea2274a6fcdba0585b5ff020d69

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in binneroc.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,24 @@
+# Binneroc
+
+Bins in constant time, O(c) or O(1).
+
+# Example
+
+My use case is a spectrum of x,y data points (an x position associated with
+some intensity y).  You would like to bin the signal into discrete bin points
+such that all the intensity is associated with equally spaced bins.  The
+simple algorithm used here finds the proper bin in constant time.
+
+xvals = [3.3, 4.5, 6.6]
+yvals = [4,    10,   2]
+
+(newx, newy) = Binneroc.bin(xvals, yvals)
+
+## Installation
+
+    gem install binneroc
+
+## Copyright
+
+MIT License.  See LICENSE.txt.
+

data/Rakefile

@@ -0,0 +1,19 @@
+require "bundler/gem_tasks"
+
+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 = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rubabel #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/binneroc.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'binneroc/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "binneroc"
+  spec.version       = Binneroc::VERSION
+  spec.authors       = ["John T. Prince"]
+  spec.email         = ["jtprince@gmail.com"]
+  spec.summary       = %q{bins x, y data into discrete bins using constant time binning}
+  spec.description   = %q{bins x, y data into discrete bins using constant time binning. Useful.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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"]
+
+  [
+    #["trollop", "~> 2.0.0"],
+  ].each do |args|
+    spec.add_dependency(*args)
+  end
+
+  [
+    ["bundler", "~> 1.5.3"],
+    ["rake"],
+    ["rspec", "~> 2.14.1"], 
+    ["rdoc", "~> 4.1.0"], 
+    ["simplecov", "~> 0.8.2"],
+  ].each do |args|
+    spec.add_development_dependency(*args)
+  end
+
+end

data/lib/binneroc/version.rb

@@ -0,0 +1,3 @@
+module Binneroc
+  VERSION = "0.0.1"
+end

data/lib/binneroc.rb

@@ -0,0 +1,192 @@
+require "binneroc/version"
+require 'bigdecimal'
+
+module Binneroc
+
+  class << self
+    # if converting from a floating point number, the precision to use
+    BIG_DECIMAL_PRECISION = 10
+  
+    # returns (new_x_coords, new_y_coords)
+    #
+    # each bin is the *minimum* for that bin. i.e., the bin includes all
+    # values starting at that point non-inclusive to that point + increment.
+    #
+    # Example: 
+    # 
+    # 
+    # Note: The final bin + increment may exceed the :stop value.
+    # Note: Values falling outside the range of start to final bin + increment
+    # will not be included.
+    #
+    #     xvals = the current x coordinates
+    #     yvals = the parallel y values
+    #
+    #     start = the starting x point for binning 
+    #                 if nil then floor of lowest xvals value
+    #     stop  = no more bins created after stop
+    #                 if nil then ceil of highest xvals value
+    #     increment = the x coordinate (binning) increment
+    #     exclude_end = *false|true how to treat stop value
+    #
+    #     default = the default value if no values lie in a bin
+    #               note that values are not added on top of the default
+    #               it is just the value used if there are no values for a bin
+    #
+    #     consider_default = true: treat the default value as the first value in the bin
+    #                        false: default considered only if no values fall in the bin
+    #
+    #     outputclass = (Array) make new arrays using this class
+    #                   needs to accept 
+    #                       ::new(array)
+    #                       ::new(size)
+    #                       ::new(size, default)
+    #
+    #     behavior = response when multiple values fall to the same bin
+    #         sum => sums all values
+    #         # below are not yet implemented but could easily be:
+    #         avg => avgs the values # not yet implemented 
+    #         max_x => takes the value at the highest x coordinate
+    #         max_y => takes the value of the highest y value (even if lower than baseline)
+    #         max_yb => takes the highest y value (includes the baseline)
+    #
+    #     return_xvals = true|false (default true)
+    #
+    # outputclass needs to be able to create a new vector like object with the
+    # arguments outputclass.new(size, value) or outputclass.new(size).
+    def bin(xvals, yvals, start: nil, stop: nil, increment: 1.0, default: 0.0, behavior: :sum, outputclass: Array, return_xvals: true, exclude_end: false, consider_default: false)
+      raise ArgumentError, "xvals and yvals need to be parallel (same size)!" unless xvals.size == yvals.size
+
+      if xvals.size == 0
+        if return_xvals
+          return [[],[]]
+        else
+          return []
+        end
+      end
+
+      increment = increment.to_f unless increment.is_a?(Float)
+
+      if start.nil? && stop.nil?
+        (min, max) = xvals.minmax
+      elsif start.nil?
+        min = xvals.min
+        stop = stop.to_f
+      elsif stop.nil?
+        max = xvals.max
+        start = start.to_f
+      end
+      start = min.floor.to_f if min
+      stop = max.ceil.to_f if max
+
+      (startbd, stopbd, incrementbd) = [start, stop, increment].map do |v| 
+        if v.is_a?(Float) 
+          BigDecimal.new(v, BIG_DECIMAL_PRECISION)
+        else
+          BigDecimal.new(v)
+        end
+      end
+
+      newsize = array_size(startbd, stopbd, incrementbd, exclude_end)
+      range = Range.new(startbd, startbd + (incrementbd * newsize), exclude_end)
+
+      yvec_new = outputclass.new(newsize, default)
+      index_bounds = (0...newsize)
+
+      case behavior
+      when :sum
+        if consider_default
+          xvals.zip(yvals) do |x, y|
+            index = ((x-startbd) / incrementbd).floor # round??
+            if index_bounds===(index)
+              yvec_new[index] += y 
+            end
+          end
+        else
+          no_default = outputclass.new(newsize, 0.0)
+          xvals.zip(yvals) do |x, y|
+            index = ((x-startbd) / incrementbd).floor # round??
+            if index_bounds===(index)
+              yvec_new[index] = no_default[index] + y
+              no_default[index] += y 
+            end
+          end
+        end
+      end
+
+      if return_xvals
+        new_xvals = range.step(incrementbd).to_a
+        new_xvals.pop if new_xvals.size > newsize
+        [outputclass.new(new_xvals), yvec_new]
+      else
+        yvec_new
+      end
+    end
+
+    # calculates the number of items that should be in the array.
+    def array_size(start, stop, step, exclude_end=false)
+      fractional_arr_sz = (stop - start) / step
+      array_size_floor = fractional_arr_sz.floor
+      array_size_floor += 1 unless exclude_end && (array_size_floor == fractional_arr_sz)
+      array_size_floor.to_i
+    end
+
+  end
+end
+
+
+
+## reference from old behavior
+
+### CREATE array to hold mapped values and write in the baseline
+#yvec_new = outputclass.new(max_ind+1-start_scaled, baseline)
+#nobl = outputclass.new(max_ind+1, 0) unless behavior == :max_x
+
+#case behavior
+#when :sum
+  #xvec_scaled.each_with_index do |ind,i|
+    #val = yvec[i]
+    #yvec_new[ind-lshift] = nobl[ind] + val
+    #nobl[ind] += val
+  #end
+#when :max_x  ## FASTEST BEHAVIOR
+  #xvec_scaled.each_with_index do |ind,i|
+    #yvec_new[ind-lshift] = yvec[i]
+  #end
+#when :avg
+  #count = Hash.new {|s,key| s[key] = 0 }
+  #xvec_scaled.each_with_index do |ind,i|
+    #val = yvec[i]
+    #yvec_new[ind-lshift] = nobl[ind] + val
+    #nobl[ind] += val
+    #count[ind] += 1
+  #end
+  #count.each do |k,co|
+    #if co > 1;  yvec_new[k-lshift] /= co end
+  #end
+#when :max_y
+  #xvec_scaled.each_with_index do |ind,i|
+    #val = yvec[i]
+    #if val > nobl[ind]
+      #yvec_new[ind-lshift] = val
+      #nobl[ind] = val 
+    #end
+  #end
+#when :max_yb
+  #xvec_scaled.each_with_index do |ind,i|
+    #val = yvec[i]
+    #if val > yvec_new[ind-lshift]
+      #yvec_new[ind-lshift] = val 
+    #end
+  #end
+#else 
+  #abort "Not a valid behavior: #{behavior.inspect}"
+#end
+
+#if return_new_xvals
+  #xvec_new = outputclass.new(newsize) 
+  #Range.new(start, stop, exclude_end).step(increment).each_with_index do |v,i|
+    #xvec_new[i] = v
+  #end
+#end
+

data/spec/binneroc_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+require 'binneroc'
+
+describe 'determining the number of bins' do
+  specify 'not excluding the end' do
+    args = [0.0, 1.0, 0.1, false]
+
+    ans = Binneroc.array_size(*args)
+    expect(ans).to eq 11
+  end
+
+  specify 'excluding the end' do
+    args = [0.0, 1.0, 0.1, true]
+
+    ans = Binneroc.array_size(*args)
+    expect(ans).to eq 10
+  end
+
+  specify 'finding with other weird values' do
+    args = [0.0, 1.0, 0.4, false]
+
+    ans = Binneroc.array_size(*args)
+    expect(ans).to eq 3
+  end
+
+end
+
+describe 'binning with no data' do
+  it 'works' do
+    (xs, ys) = Binneroc.bin([],[])
+    expect(xs).to eq []
+    expect(ys).to eq []
+
+    reply = Binneroc.bin([],[], return_xvals: false)
+    expect(reply).to eq []
+  end
+end
+
+describe 'super simple case' do
+  let(:vals) {
+    [
+      [3.15],
+      [   4]
+    ]
+  }
+
+  specify 'does not bin values outside the range' do
+    reply = Binneroc.bin(*vals, start: 3.5, stop: 4.0, increment: 1.0)
+    expect(reply).to eq [[3.5], [0.0]]
+  end
+
+  specify 'does not exclude the end point by default' do
+    reply = Binneroc.bin(*vals, start: 3.0, stop: 4.0, increment: 1.0)
+    expect(reply).to eq [[3.0, 4.0], [4, 0]]
+  end
+
+  specify 'can exclude the final end value' do
+    reply = Binneroc.bin(*vals, start: 3.0, stop: 4.0, exclude_end: true, increment: 1.0)
+    expect(reply).to eq [[3.0], [4]]
+  end
+
+  specify 'can use a default value' do
+    reply = Binneroc.bin(*vals, start: 3.0, stop: 4.0, exclude_end: false, increment: 1.0, default: 7.7)
+    expect(reply).to eq [[3.0, 4.0], [4.0, 7.7]]
+  end
+
+  specify 'can add to a default value' do
+    reply = Binneroc.bin(*vals, start: 3.0, stop: 4.0, exclude_end: false, increment: 1.0, default: 7.7, consider_default: true)
+    expect(reply).to eq [[3.0, 4.0], [11.7, 7.7]]
+  end
+
+end
+
+describe 'iconic case' do
+  let(:vals) {
+    [
+      [4.0, 4.01, 4.15, 4.2, 5.0],
+      [10,    20,   30,  40,  50]
+    ]
+  }
+
+  specify 'works' do
+    reply = Binneroc.bin(*vals, start: 4.0, stop: 5.0, increment: 0.1)
+    expect(reply).to eq [(4..5).step(0.1).to_a, [30.0, 30.0, 40.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 50.0]]
+  end
+
+  specify 'accepts string values (for BigDecimal)' do
+    reply = Binneroc.bin(*vals, start: "4.0", stop: "5.0", increment: "0.1")
+    expect(reply).to eq [(4..5).step(0.1).to_a, [30.0, 30.0, 40.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 50.0]]
+  end
+
+  specify 'can avoid returning the x values' do
+    reply = Binneroc.bin(*vals, start: "4.0", stop: "5.0", increment: "0.1", return_xvals: false)
+    expect(reply).to eq [30.0, 30.0, 40.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 50.0]
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'rspec'
+
+require 'rspec/core/formatters/progress_formatter'
+# doesn't say so much about pending guys
+class QuietPendingFormatter < RSpec::Core::Formatters::ProgressFormatter
+  def example_pending(example)
+    output.print pending_color('*')
+  end
+end
+
+require 'rspec/core/formatters/documentation_formatter'
+class QuietPendingDocFormatter < RSpec::Core::Formatters::DocumentationFormatter
+  def example_pending(example)
+    output.puts pending_color( "<pending>: #{example.execution_result[:pending_message]}" )
+  end
+end
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.formatter = QuietPendingDocFormatter
+  config.color = true
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: binneroc
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- John T. Prince
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.3
+- !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.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+- !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
+description: bins x, y data into discrete bins using constant time binning. Useful.
+email:
+- jtprince@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- binneroc.gemspec
+- lib/binneroc.rb
+- lib/binneroc/version.rb
+- spec/binneroc_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: bins x, y data into discrete bins using constant time binning
+test_files:
+- spec/binneroc_spec.rb
+- spec/spec_helper.rb