runarray 0.0.1 → 0.0.2

data/CHANGELOG

@@ -0,0 +1,5 @@
+## version 0.0.1
+* initial release as gem
+
+## version 0.0.2
+* compatible with ruby 1.9.3

data/{README → README.rdoc}

@@ -1,7 +1,7 @@
-= {Runarray}[http://rubyforge.org/projects/mspire]
+= runarray
 
-Runarray - Attempting to provide a fast, pure ruby implementation of major
-NArray functionality. 
+runarray - Attempting to provide a pure ruby implementation of major NArray
+functionality. 
 
 Pronounced like Scooby-Doo saying 'Run away!'.
 
@@ -10,7 +10,6 @@ implemented.
 
 == Example
 
-
 If you require the auto file then NArray is used if it is available.  If not, the Runarray module is included and one can seamlessly use NArray objects.
 
     require 'runarray/auto'
@@ -18,7 +17,6 @@ If you require the auto file then NArray is used if it is available.  If not, th
     na = NArray.float(4) # -> an NArray object if narray is available 
                          # -> else an Runarray::NArray object
 
-
 === Using Pure Ruby
 
     require 'runarray/narray'  

data/Rakefile

@@ -1,149 +1,45 @@
-require 'rake'
-require 'rubygems'
-require 'rake/rdoctask'
-require 'rake/gempackagetask'
-require 'rake/testtask'
-require 'rake/clean'
-require 'fileutils'
-
-###############################################
-# GLOBAL
-###############################################
-
-FL = FileList
-NAME = "runarray"
-FU = FileUtils
-
-readme = "README"
-
-rdoc_dir = 'rdoc'
-rdoc_extra_includes = [readme, "LICENSE"]
-rdoc_options = ['--main', readme, '--title', NAME, '--line-numbers', '--inline-source']
-
-lib_files = FL["lib/**/*.rb"]
-dist_files = lib_files + FL[readme, "LICENSE", "Rakefile", "{specs}/**/*"]
-changelog = 'CHANGELOG'
-
-###############################################
-# ENVIRONMENT
-###############################################
-ENV["OS"] == "Windows_NT" ? WIN32 = true : WIN32 = false
-$gemcmd = "gem"
-if WIN32
-  unless ENV["TERM"] == "cygwin"
-    $gemcmd << ".cmd"
-  end
-end
-
-
-###############################################
-# DOC
-###############################################
-Rake::RDocTask.new do |rd|
-  rd.rdoc_dir = rdoc_dir
-  rd.main = readme
-  rd.rdoc_files.include( rdoc_extra_includes )
-  rd.rdoc_files.include( lib_files.uniq )
-  rd.options.push( *rdoc_options )
-end
-
-desc "create and upload docs to server"
-task :upload_docs => [:rdoc] do
-  sh "scp -r #{rdoc_dir}/* jtprince@rubyforge.org:/var/www/gforge-projects/axml/"
-end
-
+# encoding: utf-8
 
+require 'rubygems'
+require 'rake'
 
-###############################################
-# TESTS
-###############################################
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "runarray"
+  gem.homepage = "http://github.com/jtprince/runarray"
+  gem.license = "MIT"
+  gem.summary = %Q{a pure ruby implementation of a numeric array interface}
+  gem.description = %Q{a pure ruby implementation of a numeric array interface.}
+  gem.email = "jtprince@gmail.com"
+  gem.authors = ["John T. Prince"]
+  gem.add_development_dependency "rspec", "~> 2.8.0"
+  gem.add_development_dependency "rdoc", "~> 3.12"
+  #gem.add_development_dependency "bundler", "~> 1.0.0"
+  gem.add_development_dependency "jeweler", "~> 1.8.4"
+  #gem.add_development_dependency "rcov", ">= 0"
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+#RSpec::Core::RakeTask.new(:rcov) do |spec|
+#  spec.pattern = 'spec/**/*_spec.rb'
+#  spec.rcov = true
+#end
 
-desc 'Default: Run specs.'
 task :default => :spec
 
-desc 'Run specs.'
-Rake::TestTask.new(:spec) do |t|
-  t.verbose = true
-  t.warning = true
-  ENV['RUBYOPT'] = 'rubygems'
-  ENV['TEST'] = ENV['SPEC'] if ENV['SPEC']
-  t.libs = ['lib']
-  t.test_files = Dir.glob( File.join('spec', ENV['pattern'] || '**/*_spec.rb') )
-  t.options = "-v"
-end
-
-###############################################
-# PACKAGE / INSTALL / UNINSTALL
-###############################################
-
-# looks for a header, collects the paragraph after the space
-def get_section(header, file)
-  get_space = false
-  found_space = false
-  string = ''
-  IO.foreach(file) do |line|
-    if found_space
-      if line =~ /[^\s]/
-        string << line
-      else
-        break
-      end
-    elsif get_space
-      if line !~ /[^\s]/
-        found_space = true
-        get_space = false
-      end
-    elsif line =~ /^#{header}/ 
-      get_space = true
-    end
-  end
-  string.gsub!("\n", ' ')
-end
-
-tm = Time.now
-gemspec = Gem::Specification.new do |t|
-  description = "pure ruby implementation of narray"
-  summary = "pure ruby implementation of narray"
-  t.platform = Gem::Platform::RUBY
-  t.name = NAME
-  t.version =  IO.readlines(changelog).grep(/##.*version/).pop.split(/\s+/).last.chomp
-  t.homepage = 'http://rubyforge.org/projects/mspire'
-  t.rubyforge_project = 'mspire'
-  t.summary = summary
-  t.date = "#{tm.year}-#{tm.month}-#{tm.day}"
-  t.email = "jtprince@gmail.com"
-  t.description = description
-  t.has_rdoc = true
-  t.authors = ["John Prince"]
-  t.files = dist_files
-  t.rdoc_options = rdoc_options
-  t.extra_rdoc_files = rdoc_extra_includes
-  t.executables = FL["bin/*"].map {|file| File.basename(file) }
-  t.test_files = FL["spec/**/*_spec.rb"]
-end
-
-desc "Create packages."
-Rake::GemPackageTask.new(gemspec) do |pkg|
-  #pkg.need_zip = true
-  #pkg.need_tar = true
-end
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
 
-task :remove_pkg do 
-  FileUtils.rm_rf "pkg"
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "runarray #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
 end
-
-task :install => [:reinstall]
-
-desc "uninstalls the package, packages a fresh one, and installs"
-task :reinstall => [:remove_pkg, :clean, :package] do
-  reply = `#{$gemcmd} list -l #{NAME}`
-  if reply.include?(NAME + " (")
-    %x( #{$gemcmd} uninstall -a -x #{NAME} )
-  end
-  FileUtils.cd("pkg") do
-    cmd = "#{$gemcmd} install #{NAME}*.gem"
-    puts "EXECUTING: #{cmd}" 
-    system cmd
-  end
-end
-

data/VERSION

@@ -0,0 +1 @@
+0.0.2

data/lib/runarray/narray.rb

@@ -17,8 +17,8 @@ module Runarray
       def build(typecode, *dims)
         zero = 
           case typecode
-          when 'float' : 0.0
-          when 'int' : 0
+          when 'float' then 0.0
+          when 'int' then 0
           end
         raise NotImplementedError, "dims <= 1 right now" if dims.size > 2
         case dims.size
@@ -336,9 +336,9 @@ module Runarray
       case behavior
       when "sum"
         xvec_scaled.each_with_index do |ind,i|
-        val = yvec[i]
-        arr[ind] = nobl[ind] + val
-        nobl[ind] += val
+          val = yvec[i]
+          arr[ind] = nobl[ind] + val
+          nobl[ind] += val
         end
       when "high"  ## FASTEST BEHAVIOR
         xvec_scaled.each_with_index do |ind,i|
@@ -362,8 +362,8 @@ module Runarray
         end
       when "maxb"
         xvec_scaled.each_with_index do |ind,i|
-        val = yvec[i]
-        if val > arr[ind];  arr[ind] = val end
+          val = yvec[i]
+          if val > arr[ind];  arr[ind] = val end
         end
       else 
         warn "Not a valid behavior: #{behavior}, in one_dim\n"
@@ -740,6 +740,19 @@ module Runarray
     end
 
 
+    # these are given in inclusive terms output is the array used for placing
+    # the data in (expects same size).  If nil it will be in-place.
+    def clip(min, max, output=nil)
+      output ||= self
+      self.each_with_index do |v,i|
+        n = v
+        n = min if v < min 
+        n = max if v > max
+        output[i] = n
+      end
+      output
+    end
+
     # Returns (min, max)
     def min_max
       mn = self.first
@@ -751,6 +764,108 @@ module Runarray
       return mn, mx
     end
 
+    # originally taken from a pastebin posting (2009-08-26) which is
+    # considered public domain. (http://en.pastebin.ca/1255734)
+    # self is considered the x values.  Returns y values at the x values given
+    def lowess(y, f=2.0/3.0, iter=3) 
+      x = self
+      n = x.size
+      r = (f*n).ceil.to_i
+      # h = [numpy.sort(numpy.abs(x-x[i]))[r] for i in range(n)]
+      (0...n).each { |i| (x-x[i]).abs.sort[r] }
+      raise NotImplementedError, "not finished!"
+
+      #w = numpy.clip(numpy.abs(([x]-numpy.transpose([x]))/h),0.0,1.0)
+      #w = 1-w*w*w
+      #w = w*w*w
+      #yest = numpy.zeros(n)
+      #delta = numpy.ones(n)
+      #for iteration in range(iter):
+      #  for i in range(n):
+      #    weights = delta * w[:,i]
+      #  theta = weights*x
+      #  b_top = sum(weights*y)
+      #  b_bot = sum(theta*y)
+      #  a = sum(weights)
+      #  b = sum(theta)
+      #  d = sum(theta*x)
+      #  yest[i] = (d*b_top-b*b_bot+(a*b_bot-b*b_top)*x[i])/(a*d-b**2)
+      #  residuals = y-yest
+      #  s = numpy.median(abs(residuals))
+      #  delta = numpy.clip(residuals/(6*s),-1,1)
+      #  delta = 1-delta*delta
+      #  delta = delta*delta
+      #  return yest
+
+    end
+
+
+    #"""
+    #This module implements the Lowess function for nonparametric regression.
+
+    #Functions:
+    #lowess        Fit a smooth nonparametric regression curve to a scatterplot.
+
+    #For more information, see
+
+    #William S. Cleveland: "Robust locally weighted regression and smoothing
+    #scatterplots", Journal of the American Statistical Association, December 1979,
+    #volume 74, number 368, pp. 829-836.
+
+    #William S. Cleveland and Susan J. Devlin: "Locally weighted regression: An
+    #approach to regression analysis by local fitting", Journal of the American
+    #Statistical Association, September 1988, volume 83, number 403, pp. 596-610.
+    #"""
+
+    #import numpy
+    #try:
+    #from Bio.Cluster import median
+    ## The function median in Bio.Cluster is faster than the function median
+    ## in NumPy, as it does not require a full sort.
+    #except ImportError, x:
+    ## Use the median function in NumPy if Bio.Cluster is not available
+    #from numpy import median
+
+    #def lowess(x, y, f=2./3., iter=3):
+    #"""lowess(x, y, f=2./3., iter=3) -> yest
+
+    #Lowess smoother: Robust locally weighted regression.
+    #The lowess function fits a nonparametric regression curve to a scatterplot.
+    #The arrays x and y contain an equal number of elements; each pair
+    #(x[i], y[i]) defines a data point in the scatterplot. The function returns
+    #the estimated (smooth) values of y.
+
+    #The smoothing span is given by f. A larger value for f will result in a
+    #smoother curve. The number of robustifying iterations is given by iter. The
+    #function will run faster with a smaller number of iterations."""
+    #n = len(x)
+    #r = int(numpy.ceil(f*n))
+    #h = [numpy.sort(numpy.abs(x-x[i]))[r] for i in range(n)]
+    #w = numpy.clip(numpy.abs(([x]-numpy.transpose([x]))/h),0.0,1.0)
+    #w = 1-w*w*w
+    #w = w*w*w
+    #yest = numpy.zeros(n)
+    #delta = numpy.ones(n)
+    #for iteration in range(iter):
+    #for i in range(n):
+    #weights = delta * w[:,i]
+    #theta = weights*x
+    #b_top = sum(weights*y)
+    #b_bot = sum(theta*y)
+    #a = sum(weights)
+    #b = sum(theta)
+    #d = sum(theta*x)
+    #yest[i] = (d*b_top-b*b_bot+(a*b_bot-b*b_top)*x[i])/(a*d-b**2)
+    #residuals = y-yest
+    #s = numpy.median(abs(residuals))
+    #delta = numpy.clip(residuals/(6*s),-1,1)
+    #delta = 1-delta*delta
+    #delta = delta*delta
+    #return yest
+
+
+    alias_method :loess, :lowess
+
 =begin
   # complete rewrite of the 
   # returns empty derivs for size == 0
@@ -988,13 +1103,13 @@ module Runarray
   #end
 
   #class VecI < Vec
-    #tmp = $VERBOSE ; $VERBOSE = nil
-    #@@zero = 0
-    #$VERBOSE = tmp
+  #tmp = $VERBOSE ; $VERBOSE = nil
+  #@@zero = 0
+  #$VERBOSE = tmp
 
-    #def to_rep(val)
-      #val.to_i
-    #end
+  #def to_rep(val)
+  #val.to_i
+  #end
   #end
 
 

data/spec/runarray/narray_spec.rb

@@ -1,291 +1,281 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'spec_helper'
 
 require 'narray'
 require 'runarray/narray'
 
-class Object
-  alias_method :old_must_equal, :must_equal
+shared_examples 'initializer' do
+  context 'initializes' do
 
-  def must_equal(*args)
-    if self.is_a? Runarray::NArray
-      other = args.first
-      self.each_with_index do |v,i|
-        v.old_must_equal other[i]
-      end
-    else
-      self.old_must_equal(*args)
+    before do
+      @klass = nil  # you define the class
     end
-  end
 
+    it 'initializes with different types' do
+      @klass.float(3).enums [0.0, 0.0, 0.0]
+      @klass.object(3).enums [nil, nil, nil]
+      #@klass.byte(3).enums [ ]
+    end
+  end
 end
 
-class MimicNArrayUsageSpec < MiniTest::Spec
+shared_examples 'a runarray' do
+  context 'a runarray object' do
+    include Runarray
 
-  it 'initializes floats' do
-    na = NArray.float(10)
-    runa = Runarray::NArray.float(10)
-    runa.must_equal na
-  end
+    def initialize(*args)
+      super(*args)
+      @klass = NArray
+    end
 
-end
+    it 'can be created with no arguments' do
+      @klass = NArray
+      obj1 = @klass.new
+      obj1.size.should == 0
+      obj1.class.should == @klass
+    end
 
-class RunarrayNArrayUnitSpec < MiniTest::Spec
-  include Runarray
+    it 'can be created given a desired size' do
+      size = 10
+      obj2 = @klass.new(size)
+      obj2.size.should == size
+      obj2.class.should == @klass
+    end
 
-  def initialize(*args)
-    super(*args)
-    @klass = NArray
-  end
+    it 'can be created given an array' do
+      obj3 = @klass.new([1.0,2.0,3.0])
+      obj3.size.should == 3
+      obj3.class.should == @klass
+    end
 
-  it 'can be created with no arguments' do
-    @klass = NArray
-    obj1 = @klass.new
-    obj1.size.must_equal 0
-    obj1.class.must_equal @klass
-  end
+    it 'will cast with prep and []' do
+      obj4 = @klass.new([0.0,2.0,5.0])
+      obj5 = @klass.prep([0,2,5]) # should be converted into floats
+      obj6 = @klass[0,2,5]        # should be converted into floats
+      obj4.each_index do |i|
+        obj5[i].class.should == obj4[i].class # "prep converts to floats"
+        obj6[i].class.should == obj4[i].class # "Class[] -> prep"
+      end
+    end
 
-  it 'can be created given a desired size' do
-    size = 10
-    obj2 = @klass.new(size)
-    obj2.size.must_equal size
-    obj2.class.must_equal @klass
-  end
+    it 'will NOT cast values with new' do
+      obj4 = @klass.new([0.0,2.0,5.0])
+      obj5 = @klass.prep([0,2,5]) # should be converted into floats
+      obj6 = @klass[0,2,5]        # should be converted into floats
+      obj7 = @klass.new([0,2,5])
+      obj5.should == obj4
+      obj6.should == obj4
+      obj4.each_index do |i|
+        obj7[i].class.wont_equal obj4[i].class # "w/o prep class stays int"
+      end
+    end
 
-  it 'can be created given an array' do
-    obj3 = @klass.new([1.0,2.0,3.0])
-    obj3.size.must_equal 3
-    obj3.class.must_equal @klass
-  end
+    it 'will call itself equal to another object if all vals equal' do
+      obj4 = @klass.new([0.0,2.0,5.0])
+      obj4.should == [0.0,2.0,5.0] # "arrays and objs may be equal"
+      obj4.should == [0,2,5] # even if the types arr different, but equal val"
 
-  it 'will cast with prep and []' do
-    obj4 = @klass.new([0.0,2.0,5.0])
-    obj5 = @klass.prep([0,2,5]) # should be converted into floats
-    obj6 = @klass[0,2,5]        # should be converted into floats
-    obj4.each_index do |i|
-      obj5[i].class.must_equal obj4[i].class # "prep converts to floats"
-      obj6[i].class.must_equal obj4[i].class # "Class[] -> prep"
+      obj8 = @klass[0,2,5]
+      obj9 = @klass.new(obj8)
+      obj9.should == obj8 #  "new from #{@klass} object"
+      obj9.class.should == obj8.class 
     end
-  end
 
-  it 'will NOT cast values with new' do
-    obj4 = @klass.new([0.0,2.0,5.0])
-    obj5 = @klass.prep([0,2,5]) # should be converted into floats
-    obj6 = @klass[0,2,5]        # should be converted into floats
-    obj7 = @klass.new([0,2,5])
-    obj5.must_equal obj4
-    obj6.must_equal obj4
-    obj4.each_index do |i|
-      obj7[i].class.wont_equal obj4[i].class # "w/o prep class stays int"
+    it 'can do division' do
+      x = NArray[8,4,2]
+      y = NArray[4,2,1]
+      (x / 2).should == NArray[4,2,1]
+      vec_by_vec = NArray[2,2,2]
+      (x / y).should == vec_by_vec
+      x /= y
+      x.should == vec_by_vec
     end
-  end
 
-  it 'will call itself equal to another object if all vals equal' do
-    obj4 = @klass.new([0.0,2.0,5.0])
-    obj4.must_equal [0.0,2.0,5.0] # "arrays and objs may be equal"
-    obj4.must_equal [0,2,5] # even if the types arr different, but equal val"
-
-    obj8 = @klass[0,2,5]
-    obj9 = @klass.new(obj8)
-    obj9.must_equal obj8 #  "new from #{@klass} object"
-    obj9.class.must_equal obj8.class 
-  end
+    it 'can do addition' do
+      x = NArray[8,4,2]
+      y = NArray[4,2,1]
+      vec_by_vec = NArray[12,6,3]
+      (x + y).should == vec_by_vec
+      (x + 2).should == NArray[10,6,4]
+      x += y
+      x.should == vec_by_vec
+    end
 
-  it 'can do division' do
-    x = NArray[8,4,2]
-    y = NArray[4,2,1]
-    (x / 2).must_equal NArray[4,2,1]
-    vec_by_vec = NArray[2,2,2]
-    (x / y).must_equal vec_by_vec
-    x /= y
-    x.must_equal vec_by_vec
-  end
+    it 'can do multiplication' do
+      x = NArray[8,4,2]
+      y = NArray[4,2,1]
+      vec_by_vec = NArray[32,8,2]
+      (x * y).should == vec_by_vec
+      (x * 2).should == NArray[16,8,4]
+      x *= y
+      x.should == vec_by_vec
+    end
 
-  it 'can do addition' do
-    x = NArray[8,4,2]
-    y = NArray[4,2,1]
-    vec_by_vec = NArray[12,6,3]
-    (x + y).must_equal vec_by_vec
-    (x + 2).must_equal NArray[10,6,4]
-    x += y
-    x.must_equal vec_by_vec
-  end
-  
-  it 'can do multiplication' do
-    x = NArray[8,4,2]
-    y = NArray[4,2,1]
-    vec_by_vec = NArray[32,8,2]
-    (x * y).must_equal vec_by_vec
-    (x * 2).must_equal NArray[16,8,4]
-    x *= y
-    x.must_equal vec_by_vec
-  end
+    it 'can do subtraction' do
+      x = NArray[8,4,2]
+      y = NArray[4,2,1]
+      vec_by_vec = NArray[4,2,1]
+      (x - y).should == vec_by_vec
+      (x - 2).should == NArray[6,2,0]
+      x -= y
+      x.should == vec_by_vec
+    end
 
-  it 'can do subtraction' do
-    x = NArray[8,4,2]
-    y = NArray[4,2,1]
-    vec_by_vec = NArray[4,2,1]
-    (x - y).must_equal vec_by_vec
-    (x - 2).must_equal NArray[6,2,0]
-    x -= y
-    x.must_equal vec_by_vec
-  end
+    it 'can calculate orders' do
+      x = NArray[0.05, 0.5, 0.0009, 0.05, 0.5]
+      x.order.should == [2,0,3,1,4]
+    end
 
-  it 'can calculate orders' do
-    x = NArray[0.05, 0.5, 0.0009, 0.05, 0.5]
-    x.order.must_equal [2,0,3,1,4]
-  end
+    def _inc_x(x,y,xexp, exp,mz_start,mz_end,inc,bl,type)
+      (xvec, answ) = x.inc_x(y,mz_start,mz_end,inc,bl,type)
+      xvec == xexp and answ.class == x.class and answ == exp
+    end
 
-  def _inc_x(x,y,xexp, exp,mz_start,mz_end,inc,bl,type)
-    (xvec, answ) = x.inc_x(y,mz_start,mz_end,inc,bl,type)
-    xvec == xexp and answ.class == x.class and answ == exp
-  end
+    it 'works for _inc_x (private)' do
+
+      bl = 33
+      x = NArray.new([300, 301, 302, 304, 304, 304.2, 305, 306, 307.6])
+      y = NArray.new([10, 20,  30,  50 , 55,  54,    70,  80,  90])
+      xexp = (300..310).to_a
+      exp = [10, 20, 30, bl, 159, 70, 80, bl, 90, bl, bl]
+      _inc_x(x,y,xexp,exp,300,310,1,bl,"sum").should == true
+
+      bl = 33
+      x = NArray.new([300, 301, 302, 304, 304, 304.2, 305, 306, 307.6])
+      y = NArray.new([10, 20,  30,  50 , 55,  54,    70,  80,  90])
+      xexp = (300..310).to_a
+      exp = [10, 20, 30, bl, 55, 70, 80, bl, 90, bl, bl]
+      _inc_x(x,y,xexp,exp,300,310, 1, bl, "max" ).should == true
+
+      bl = 15
+      x = NArray.new([300, 301, 302, 304, 304, 304.2, 305, 306, 307.6])
+      y = NArray.new([10, 20,  30,  50 , 55,  54,    70,  80,  90])
+      xexp = (300..310).to_a
+      exp = [bl, 20, 30, bl, 55, 70, 80, bl, 90, bl, bl]
+      _inc_x(x,y,xexp,exp, 300, 310, 1, bl, "maxb" ).should == true
+
+      bl = 33
+      x = NArray.new([300, 301, 302, 304, 304, 304.2, 305, 306, 307.6])
+      y = NArray.new([10, 20,  30,  50 , 55,  54,    70,  80,  90])
+      xexp = (300..310).to_a
+      exp = [10, 20, 30, bl, 54, 70, 80, bl, 90, bl, bl]
+      _inc_x(x,y,xexp,exp, 300, 310, 1, bl, "high" ).should == true
+
+      bl = 33
+      x = NArray.new([300, 301, 302, 304, 304, 304.2, 305, 306, 307.6])
+      y = NArray.new([10, 20,  30,  50 , 62,  68, 70,  80,  90])
+      xexp = (300..310).to_a
+      exp = [10, 20, 30, bl, 60, 70, 80, bl, 90, bl, bl]
+      _inc_x(x,y,xexp,exp, 300, 310, 1, bl, "avg" ).should == true
 
-  it 'works for _inc_x (private)' do
-
-    bl = 33
-    x = NArray.new([300, 301, 302, 304, 304, 304.2, 305, 306, 307.6])
-    y = NArray.new([10, 20,  30,  50 , 55,  54,    70,  80,  90])
-    xexp = (300..310).to_a
-    exp = [10, 20, 30, bl, 159, 70, 80, bl, 90, bl, bl]
-    _inc_x(x,y,xexp,exp,300,310,1,bl,"sum").must_equal true
-
-    bl = 33
-    x = NArray.new([300, 301, 302, 304, 304, 304.2, 305, 306, 307.6])
-    y = NArray.new([10, 20,  30,  50 , 55,  54,    70,  80,  90])
-    xexp = (300..310).to_a
-    exp = [10, 20, 30, bl, 55, 70, 80, bl, 90, bl, bl]
-    _inc_x(x,y,xexp,exp,300,310, 1, bl, "max" ).must_equal true
-
-    bl = 15
-    x = NArray.new([300, 301, 302, 304, 304, 304.2, 305, 306, 307.6])
-    y = NArray.new([10, 20,  30,  50 , 55,  54,    70,  80,  90])
-    xexp = (300..310).to_a
-    exp = [bl, 20, 30, bl, 55, 70, 80, bl, 90, bl, bl]
-    _inc_x(x,y,xexp,exp, 300, 310, 1, bl, "maxb" ).must_equal true
-
-    bl = 33
-    x = NArray.new([300, 301, 302, 304, 304, 304.2, 305, 306, 307.6])
-    y = NArray.new([10, 20,  30,  50 , 55,  54,    70,  80,  90])
-    xexp = (300..310).to_a
-    exp = [10, 20, 30, bl, 54, 70, 80, bl, 90, bl, bl]
-    _inc_x(x,y,xexp,exp, 300, 310, 1, bl, "high" ).must_equal true
-
-    bl = 33
-    x = NArray.new([300, 301, 302, 304, 304, 304.2, 305, 306, 307.6])
-    y = NArray.new([10, 20,  30,  50 , 62,  68, 70,  80,  90])
-    xexp = (300..310).to_a
-    exp = [10, 20, 30, bl, 60, 70, 80, bl, 90, bl, bl]
-    _inc_x(x,y,xexp,exp, 300, 310, 1, bl, "avg" ).must_equal true
+    end
 
-  end
+    it 'uses index notation' do
+      obj1 = NArray.new(10)
+      obj1[0].nil?.should == true
+      obj1[0] = 1
+      obj1[0].should == 1
+    end
 
-  it 'uses index notation' do
-    obj1 = NArray.new(10)
-    obj1[0].nil?.must_equal true
-    obj1[0] = 1
-    obj1[0].must_equal 1
-  end
+    it 'can calculate Pearsons R' do
+      x = NArray.new([0,1,2,3,4,5,6,7,8,9,10])
+      y = NArray.new([3,4,5,6,9,6,5,4,3,4,5])
+      x.pearsons_r(y).should be_within(1e-12).of(0.0709326902131908)
+    end
 
-  it 'can calculate Pearsons R' do
-    x = NArray.new([0,1,2,3,4,5,6,7,8,9,10])
-    y = NArray.new([3,4,5,6,9,6,5,4,3,4,5])
-    x.pearsons_r(y).must_be_close_to(-0.0709326902131908, 0.000000000001)
-  end
+    it 'can calculate rsq slope and intercept' do
+      obj1 = NArray[0,2,5,5]
+      obj2 = NArray[1,3,4,7]
+      rsq, slope, inter = obj1.rsq_slope_intercept(obj2)
+      rsq.should be_within(1e-6).of(0.758519)
+      slope.should be_within(1e-6).of(0.888888888)
+      inter.should be_within(1e-6).of(1.083333333)
+
+      obj3 = NArray[1,3]
+      obj4 = NArray[2,4]
+      rsq, slope, inter = obj3.rsq_slope_intercept(obj4)
+      [rsq, slope, inter].each {|v| v.should == 1.0 }
+    end
 
-  it 'can calculate rsq slope and intercept' do
-    obj1 = NArray[0,2,5,5]
-    obj2 = NArray[1,3,4,7]
-    rsq, slope, inter = obj1.rsq_slope_intercept(obj2)
-    rsq.must_be_close_to(0.758519, 0.000001)
-    slope.must_be_close_to(0.888888888, 0.000001)
-    inter.must_be_close_to(1.083333333, 0.000001)
-
-    obj3 = NArray[1,3]
-    obj4 = NArray[2,4]
-    rsq, slope, inter = obj3.rsq_slope_intercept(obj4)
-    [rsq, slope, inter].each {|v| v.must_equal 1.0 }
-  end
 
+    xit 'can find residuals from least squares' do
+      obj1 = NArray[0,2,5,5]
+      obj2 = NArray[1,3,4,7]
+      out = obj1.residuals_from_least_squares(obj2)
+      out.size.should == 4
+      # frozen
+      [-0.141112436470222, 0.235187394117037, -2.58706133528741, 2.49298637764059].zip(out) do |exp, ans|
+        ans.should be_within(0.0000000001).of(exp)
+      end
+    end
 
-  xit 'can find residuals from least squares' do
-    obj1 = NArray[0,2,5,5]
-    obj2 = NArray[1,3,4,7]
-    out = obj1.residuals_from_least_squares(obj2)
-    out.size.must_equal 4
-    # frozen
-    [-0.141112436470222, 0.235187394117037, -2.58706133528741, 2.49298637764059].zip(out) do |exp, ans|
-      ans.must_be_close_to(exp, 0.0000000001)
+    it 'can find sample stats (mean and stdev)' do
+      obj1 = NArray[0,2,5,5,6,7]
+      mean, std_dev = obj1.sample_stats
+      mean.should be_within(0.00001).of(4.166666)
+      std_dev.should be_within(0.00001).of(2.639444)
     end
-  end
 
-  it 'can find sample stats (mean and stdev)' do
-    obj1 = NArray[0,2,5,5,6,7]
-    mean, std_dev = obj1.sample_stats
-    mean.must_be_close_to(4.166666, 0.00001)
-    std_dev.must_be_close_to(2.639444, 0.00001)
-  end
+    xit 'can find outliers by index' do
+      NArray[0,1,1,2,1,2,10,1,0,0,1].outliers(2).should == [6]
+      NArray[0,-10,1,2,1,2,10,1,0,0,1].outliers(2).should == [1,6]
+    end
 
-  xit 'can find outliers by index' do
-    NArray[0,1,1,2,1,2,10,1,0,0,1].outliers(2).must_equal [6]
-    NArray[0,-10,1,2,1,2,10,1,0,0,1].outliers(2).must_equal [1,6]
-  end
+    xit 'can find outliers iteratively' do
+      NArray[-1,-1,0,0,0,0,1,1,15,100].outliers(2).should == [9]
+      NArray[-1,-1,0,0,0,0,1,1,15,100].outliers_iteratively(2).should == [8,9]
+    end
 
-  xit 'can find outliers iteratively' do
-    NArray[-1,-1,0,0,0,0,1,1,15,100].outliers(2).must_equal [9]
-    NArray[-1,-1,0,0,0,0,1,1,15,100].outliers_iteratively(2).must_equal [8,9]
-  end
+    xit 'can delete outliers (for least squares residuals)' do
+      # Consistency/sanity checks right now (not accuracy)
+      x = NArray[-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,10,0 ,1,2,3,4,5,6,7,8,9]
+      y = NArray[-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,0 ,10,1,2,3,4,5,6,7,8,9]
+
+      nx1, ny1 = x.delete_outliers(3.2, y) 
+      expx1 = NArray[-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,10,1,2,3,4,5,6,7,8,9]
+      expy1 = NArray[-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,0 ,1,2,3,4,5,6,7,8,9]
+      nx1.should == expx1
+      ny1.should == expy1
+
+      nx2, ny2 = x.delete_outliers(2.8, y) 
+      expx2 = NArray[-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,1,2,3,4,5,6,7,8,9]
+      expy2 = NArray[-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,1,2,3,4,5,6,7,8,9]
+      nx2.should == expx2
+      ny2.should == expy2
+
+      #res = nx1.residuals_from_least_squares(ny1)
+      #mean, std = res.sample_stats
+      #puts res/std
+
+      nx, ny = x.delete_outliers_iteratively(3.2, y) 
+      nx.should == expx2
+      ny.should == expy2
+    end
 
-  xit 'can delete outliers (for least squares residuals)' do
-    # Consistency/sanity checks right now (not accuracy)
-    x = NArray[-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,10,0 ,1,2,3,4,5,6,7,8,9]
-    y = NArray[-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,0 ,10,1,2,3,4,5,6,7,8,9]
-
-    nx1, ny1 = x.delete_outliers(3.2, y) 
-    expx1 = NArray[-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,10,1,2,3,4,5,6,7,8,9]
-    expy1 = NArray[-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,0 ,1,2,3,4,5,6,7,8,9]
-    nx1.must_equal expx1
-    ny1.must_equal expy1
-
-    nx2, ny2 = x.delete_outliers(2.8, y) 
-    expx2 = NArray[-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,1,2,3,4,5,6,7,8,9]
-    expy2 = NArray[-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,1,2,3,4,5,6,7,8,9]
-    nx2.must_equal expx2
-    ny2.must_equal expy2
-
-    #res = nx1.residuals_from_least_squares(ny1)
-    #mean, std = res.sample_stats
-    #puts res/std
-
-    nx, ny = x.delete_outliers_iteratively(3.2, y) 
-    nx.must_equal expx2
-    ny.must_equal expy2
-  end
+    xit 'finds outliers (for least squares residuals)' do
+      # Consistency/sanity checks right now (not accuracy)
+      x = NArray[-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,10,0 ,1,2,3,7,5,6,7,8,9]
+      y = NArray[-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,0 ,10,1,2,3,4,5,6,7,8,9]
+      xdup = x
+      ydup = y
 
-  xit 'finds outliers (for least squares residuals)' do
-    # Consistency/sanity checks right now (not accuracy)
-    x = NArray[-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,10,0 ,1,2,3,7,5,6,7,8,9]
-    y = NArray[-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,0 ,10,1,2,3,4,5,6,7,8,9]
-    xdup = x
-    ydup = y
+      ind = x.outliers(0.5, y) 
+      ind.should == [10,11,15]
 
-    ind = x.outliers(0.5, y) 
-    ind.must_equal [10,11,15]
+      ind = x.outliers(0.7, y) 
+      ind.should == [10,11]
 
-    ind = x.outliers(0.7, y) 
-    ind.must_equal [10,11]
+      ind2 = x.outliers_iteratively(0.7, y)
+      ind2.should == [10,11,15]
+      x.should == xdup # "method didn't change vector"
+      y.should == ydup # "method didn't change vector"
+    end
 
-    ind2 = x.outliers_iteratively(0.7, y)
-    ind2.must_equal [10,11,15]
-    x.must_equal xdup # "method didn't change vector"
-    y.must_equal ydup # "method didn't change vector"
-  end
-  
-  it 'finds _correct_indices (private)' do
-    NArray.new._correct_indices([[5],[0,3],[3],[1,4]]).must_equal [0,2,3,5,6,8]
-  end
+    it 'finds _correct_indices (private)' do
+      NArray.new._correct_indices([[5],[0,3],[3],[1,4]]).should == [0,2,3,5,6,8]
+    end
 
-  # TODO: fix this spec
-  # something is wrong in this guy
+    # TODO: fix this spec
+    # something is wrong in this guy
 =begin
   it 'can noisify its values' do
     [[100,10,1],[-100,-10,-1]].each do |arr|
@@ -298,70 +288,72 @@ class RunarrayNArrayUnitSpec < MiniTest::Spec
         x = NArray.prep([0,2,3,5,6,8])
         x.noisify!(fraction)
         xdup.zip(x) do |arr|
-          arr[1].must_be_close_to(arr[0], (fraction*arr[0]).abs)
+
+          arr[1].should be_within((fraction*arr[0]).abs).of( arr[0] )
         end
       end
     end
   end
 =end
- 
-  it 'can duplicate itself' do
-    x = NArray[100,10,1]
-    d = x.dup
-    d.must_equal x
-    d.class.must_equal x.class
-    x[0] = 10.0
-    d.wont_equal x
-  end
 
-  it 'can do a moving average' do
-    obj = NArray[0,1,2,3,4,5,6].moving_avg
-    obj.must_equal [0.5, 1.0, 2.0, 3.0, 4.0, 5.0, 5.5]
-    obj = NArray[0,1,2,3,10,5,6].moving_avg
-    obj.must_equal [0.5, 1.0, 2.0, 5.0, 6.0, 7.0, 5.5]
+    it 'can duplicate itself' do
+      x = NArray[100,10,1]
+      d = x.dup
+      d.should == x
+      d.class.should == x.class
+      x[0] = 10.0
+      d.wont_equal x
+    end
 
-    obj = NArray[0,1,2,3,4,5,6].moving_avg(4,4).must_equal [2.0, 2.5, 3.0, 3.0, 3.0, 3.5, 4.0]
-    obj = NArray[0,1,2,3,4,5,6].moving_avg(0,6).must_equal [3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0]
-    obj = NArray[0,1,2,3,4,5,6].moving_avg(6,0).must_equal [0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0]
-  end
+    it 'can do a moving average' do
+      obj = NArray[0,1,2,3,4,5,6].moving_avg
+      obj.should == [0.5, 1.0, 2.0, 3.0, 4.0, 5.0, 5.5]
+      obj = NArray[0,1,2,3,10,5,6].moving_avg
+      obj.should == [0.5, 1.0, 2.0, 5.0, 6.0, 7.0, 5.5]
 
-  it 'can find 3-point derivatives (with chim)' do
-    x = NArray[1]
-    y = NArray[2]
-    derivs = x.chim(y)
-    derivs.must_equal [0]
-
-    x = NArray[1,2]
-    y = NArray[2,4]
-    derivs = x.chim(y)
-    derivs.must_equal [2.0, 2.0]
-
-    x = NArray[0,1,2,3,4,5,6,7,8,9]
-    y = NArray[0,10,12,4,5,2,7,9,10,4]
-    derivs = x.chim(y)
-    [14, 3.3333333, 0, 0, 0, 0, 2.8571429, 1.3333333, 0, -9.5].zip(derivs) do |exp, act|
-      act.must_be_close_to(exp, 0.0001)
+      obj = NArray[0,1,2,3,4,5,6].moving_avg(4,4).should == [2.0, 2.5, 3.0, 3.0, 3.0, 3.5, 4.0]
+      obj = NArray[0,1,2,3,4,5,6].moving_avg(0,6).should == [3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0]
+      obj = NArray[0,1,2,3,4,5,6].moving_avg(6,0).should == [0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0]
     end
- 
-  end
 
-  it 'can do custom transformations (moving avg, stdev, etc)' do
-    vec = NArray[0,1,2,3,3,4,2,1]
-    # a three point moving average:
-    answ = vec.transform(1, 1) {|x| x.avg }
-    exp = [0.5, 1, 2, 8.0/3, 10.0/3, 3, 7.0/3, 3.0/2]
-    answ.must_equal exp
-
-    # 5 point stdeviation transformation
-    pre = 2
-    post = 2
-    # transform with the standard deviation
-    answ = vec.transform(pre, post) {|x| x.sample_stats[1] }
-    exp = [1.0, 1.29099444873581, 1.30384048104053, 1.14017542509914, 0.836660026534075, 1.14017542509914, 1.29099444873581, 1.52752523165195]
-    answ.zip(exp) do |ans, ex|
-      ans.must_be_close_to(ex, 0.000000001)
+    it 'can find 3-point derivatives (with chim)' do
+      x = NArray[1]
+      y = NArray[2]
+      derivs = x.chim(y)
+      derivs.should == [0]
+
+      x = NArray[1,2]
+      y = NArray[2,4]
+      derivs = x.chim(y)
+      derivs.should == [2.0, 2.0]
+
+      x = NArray[0,1,2,3,4,5,6,7,8,9]
+      y = NArray[0,10,12,4,5,2,7,9,10,4]
+      derivs = x.chim(y)
+      [14, 3.3333333, 0, 0, 0, 0, 2.8571429, 1.3333333, 0, -9.5].zip(derivs) do |exp, act|
+        act.should be_within(0.0001).of(exp)
+      end
+
     end
-  end
 
+    it 'can do custom transformations (moving avg, stdev, etc)' do
+      vec = NArray[0,1,2,3,3,4,2,1]
+      # a three point moving average:
+      answ = vec.transform(1, 1) {|x| x.avg }
+      exp = [0.5, 1, 2, 8.0/3, 10.0/3, 3, 7.0/3, 3.0/2]
+      answ.should == exp
+
+      # 5 point stdeviation transformation
+      pre = 2
+      post = 2
+      # transform with the standard deviation
+      answ = vec.transform(pre, post) {|x| x.sample_stats[1] }
+      exp = [1.0, 1.29099444873581, 1.30384048104053, 1.14017542509914, 0.836660026534075, 1.14017542509914, 1.29099444873581, 1.52752523165195]
+      answ.zip(exp) do |ans, ex|
+        ans.should be_within(0.000000001).of(ex)
+      end
+    end
+
+  end
 
 end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+
+require 'rubygems'
+require 'rspec'
+
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+#Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.color_enabled = true
+  config.tty = true
+  config.formatter = :documentation  # :progress, :html, :textmate
+  #config.formatter = :progress # :progress, :html, :textmate
+end

metadata

@@ -1,66 +1,106 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: runarray
-version: !ruby/object:Gem::Version 
-  version: 0.0.1
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
 platform: ruby
-authors: 
-- John Prince
+authors:
+- John T. Prince
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2009-05-14 00:00:00 -06:00
-default_executable: 
-dependencies: []
-
-description: pure ruby implementation of narray
+date: 2013-02-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+description: a pure ruby implementation of a numeric array interface.
 email: jtprince@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- README
+extra_rdoc_files:
 - LICENSE
-files: 
-- lib/runarray/auto.rb
-- lib/runarray/narray.rb
-- lib/runarray.rb
-- README
+- README.rdoc
+files:
+- CHANGELOG
 - LICENSE
+- README.rdoc
 - Rakefile
-has_rdoc: true
-homepage: http://rubyforge.org/projects/mspire
-licenses: []
-
+- VERSION
+- lib/.vecutils.rb.swp
+- lib/runarray.rb
+- lib/runarray/auto.rb
+- lib/runarray/narray.rb
+- spec/runarray/narray_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/jtprince/runarray
+licenses:
+- MIT
 post_install_message: 
-rdoc_options: 
-- --main
-- README
-- --title
-- runarray
-- --line-numbers
-- --inline-source
-require_paths: 
+rdoc_options: []
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: mspire
-rubygems_version: 1.3.2
+rubyforge_project: 
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: pure ruby implementation of narray
-test_files: 
-- spec/runarray/narray_spec.rb
+summary: a pure ruby implementation of a numeric array interface
+test_files: []