wector 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: af75df7e08d5f55b00bab2d8d60045b3dba237a6
-  data.tar.gz: f91fcb8821ba7bc30342c9c299f7a70f3c32c544
+  metadata.gz: 0613c1e66c0f9851a255f769abe58b3f7f66b92f
+  data.tar.gz: f2aa4eee978e2b52983b2df26a5c944c9a888683
 SHA512:
-  metadata.gz: dd1090d7821a26e93789b20d2e9b45559d968caf97bbe2a981d7c5a6d130fa63cf509fcf1301a24754ddca1181ee9022031b596680827bb566ae691c04889fe7
-  data.tar.gz: d14805939d4f2d016d3b2ddfb0d6364e6198c5b6789d2cc48c00c35de21b20756fcc3e200dfcb9b4d110a1e3bf69a43afc26ce463a88000687b132e6125a36de
+  metadata.gz: 1daeda348061db6b1f155933f94f80d700993a9ba9dbd0e38175aff5db4386b63e7330e0b616a1a343218f4be1224951575777c4793ef34b699c44fbb00b16ee
+  data.tar.gz: 0cd1e7cea379ae9c8731a63f12d4223ebce60efe9bc45610ce16e398d52280a0251b2348e979671df7184ecde3c5dd7683a8cc94c05d5411a3426369a9ade5cf

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - jruby-18mode # JRuby in 1.8 mode
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-18mode
+  - rbx-19mode
+  - 1.8.7

data/README.md

@@ -1,4 +1,5 @@
 # Wector
+[![Build Status](https://travis-ci.org/Qard/wector.png)](https://travis-ci.org/Qard/wector)
 
 Wector does what we all wish the built-in Vector class did; it makes vector math easy by allowing any method of the Numeric interface to be used to combine two arrays or an array and a number.
 

data/Rakefile

@@ -1,3 +1,7 @@
+task :build do
+	`cd src && ruby build.rb`
+end
+
 require "bundler/gem_tasks"
 require 'rake/testtask'
 

data/lib/wector.rb

@@ -1,4 +1,8 @@
 class Wector < Array
+
+  # 
+  # wector.[]
+  # 
   def [](*args)
     args.each do |arg|
       raise "Non-numeric item" unless arg.is_a?(Integer) or arg.is_a?(Float)
@@ -371,60 +375,6 @@ class Wector < Array
     end
   end
   
-  # 
-  # wector.gcd
-  # 
-  # Arguments:
-  #   other: (Array)
-  # 
-  def gcd(other)
-    if other.is_a? Array
-      raise "Incorrect Dimensions" unless self.size == other.size
-      other = other.dup
-      self.class.new(map { |i| i.gcd other.shift })
-    elsif other.is_a?(Integer) or other.is_a?(Float)
-      self.class.new(map { |i| i.gcd other })
-    else
-      super
-    end
-  end
-  
-  # 
-  # wector.gcdlcm
-  # 
-  # Arguments:
-  #   other: (Array)
-  # 
-  def gcdlcm(other)
-    if other.is_a? Array
-      raise "Incorrect Dimensions" unless self.size == other.size
-      other = other.dup
-      self.class.new(map { |i| i.gcdlcm other.shift })
-    elsif other.is_a?(Integer) or other.is_a?(Float)
-      self.class.new(map { |i| i.gcdlcm other })
-    else
-      super
-    end
-  end
-  
-  # 
-  # wector.lcm
-  # 
-  # Arguments:
-  #   other: (Array)
-  # 
-  def lcm(other)
-    if other.is_a? Array
-      raise "Incorrect Dimensions" unless self.size == other.size
-      other = other.dup
-      self.class.new(map { |i| i.lcm other.shift })
-    elsif other.is_a?(Integer) or other.is_a?(Float)
-      self.class.new(map { |i| i.lcm other })
-    else
-      super
-    end
-  end
-  
   # 
   # wector.quo
   # 
@@ -443,24 +393,6 @@ class Wector < Array
     end
   end
   
-  # 
-  # wector.rationalize
-  # 
-  # Arguments:
-  #   other: (Array)
-  # 
-  def rationalize(other)
-    if other.is_a? Array
-      raise "Incorrect Dimensions" unless self.size == other.size
-      other = other.dup
-      self.class.new(map { |i| i.rationalize other.shift })
-    elsif other.is_a?(Integer) or other.is_a?(Float)
-      self.class.new(map { |i| i.rationalize other })
-    else
-      super
-    end
-  end
-  
   # 
   # wector.remainder
   # 
@@ -479,24 +411,6 @@ class Wector < Array
     end
   end
   
-  # 
-  # wector.round
-  # 
-  # Arguments:
-  #   other: (Array)
-  # 
-  def round(other)
-    if other.is_a? Array
-      raise "Incorrect Dimensions" unless self.size == other.size
-      other = other.dup
-      self.class.new(map { |i| i.round other.shift })
-    elsif other.is_a?(Integer) or other.is_a?(Float)
-      self.class.new(map { |i| i.round other })
-    else
-      super
-    end
-  end
-  
   
   # 
   # wector.ceil
@@ -512,62 +426,6 @@ class Wector < Array
     self.class.new(map { |i| i.abs })
   end
   
-  # 
-  # wector.abs2
-  # 
-  def abs2
-    self.class.new(map { |i| i.abs2 })
-  end
-  
-  # 
-  # wector.magnitude
-  # 
-  def magnitude
-    self.class.new(map { |i| i.magnitude })
-  end
-  
-  # 
-  # wector.arg
-  # 
-  def arg
-    self.class.new(map { |i| i.arg })
-  end
-  
-  # 
-  # wector.angle
-  # 
-  def angle
-    self.class.new(map { |i| i.angle })
-  end
-  
-  # 
-  # wector.phase
-  # 
-  def phase
-    self.class.new(map { |i| i.phase })
-  end
-  
-  # 
-  # wector.conj
-  # 
-  def conj
-    self.class.new(map { |i| i.conj })
-  end
-  
-  # 
-  # wector.conjugate
-  # 
-  def conjugate
-    self.class.new(map { |i| i.conjugate })
-  end
-  
-  # 
-  # wector.denominator
-  # 
-  def denominator
-    self.class.new(map { |i| i.denominator })
-  end
-  
   # 
   # wector.even?
   # 
@@ -582,20 +440,6 @@ class Wector < Array
     self.class.new(map { |i| i.floor })
   end
   
-  # 
-  # wector.imag
-  # 
-  def imag
-    self.class.new(map { |i| i.imag })
-  end
-  
-  # 
-  # wector.imaginary
-  # 
-  def imaginary
-    self.class.new(map { |i| i.imaginary })
-  end
-  
   # 
   # wector.integer?
   # 
@@ -617,20 +461,6 @@ class Wector < Array
     self.class.new(map { |i| i.odd? })
   end
   
-  # 
-  # wector.numerator
-  # 
-  def numerator
-    self.class.new(map { |i| i.numerator })
-  end
-  
-  # 
-  # wector.polar
-  # 
-  def polar
-    self.class.new(map { |i| i.polar })
-  end
-  
   # 
   # wector.pred
   # 
@@ -638,27 +468,6 @@ class Wector < Array
     self.class.new(map { |i| i.pred })
   end
   
-  # 
-  # wector.real
-  # 
-  def real
-    self.class.new(map { |i| i.real })
-  end
-  
-  # 
-  # wector.real?
-  # 
-  def real?
-    self.class.new(map { |i| i.real? })
-  end
-  
-  # 
-  # wector.rect
-  # 
-  def rect
-    self.class.new(map { |i| i.rect })
-  end
-  
   # 
   # wector.truncate
   # 
@@ -673,6 +482,208 @@ class Wector < Array
     self.class.new(map { |i| i.zero? })
   end
   
+
+  # Only support 1.9+ features when available
+  v = RUBY_VERSION.split('.')
+  if v[0].to_i > 1 or v[1].to_i > 8
+    
+    # 
+    # wector.gcd
+    # 
+    # Arguments:
+    #   other: (Array)
+    # 
+    def gcd(other)
+      if other.is_a? Array
+        raise "Incorrect Dimensions" unless self.size == other.size
+        other = other.dup
+        self.class.new(map { |i| i.gcd other.shift })
+      elsif other.is_a?(Integer) or other.is_a?(Float)
+        self.class.new(map { |i| i.gcd other })
+      else
+        super
+      end
+    end
+    
+    # 
+    # wector.gcdlcm
+    # 
+    # Arguments:
+    #   other: (Array)
+    # 
+    def gcdlcm(other)
+      if other.is_a? Array
+        raise "Incorrect Dimensions" unless self.size == other.size
+        other = other.dup
+        self.class.new(map { |i| i.gcdlcm other.shift })
+      elsif other.is_a?(Integer) or other.is_a?(Float)
+        self.class.new(map { |i| i.gcdlcm other })
+      else
+        super
+      end
+    end
+    
+    # 
+    # wector.lcm
+    # 
+    # Arguments:
+    #   other: (Array)
+    # 
+    def lcm(other)
+      if other.is_a? Array
+        raise "Incorrect Dimensions" unless self.size == other.size
+        other = other.dup
+        self.class.new(map { |i| i.lcm other.shift })
+      elsif other.is_a?(Integer) or other.is_a?(Float)
+        self.class.new(map { |i| i.lcm other })
+      else
+        super
+      end
+    end
+    
+    # 
+    # wector.rationalize
+    # 
+    # Arguments:
+    #   other: (Array)
+    # 
+    def rationalize(other)
+      if other.is_a? Array
+        raise "Incorrect Dimensions" unless self.size == other.size
+        other = other.dup
+        self.class.new(map { |i| i.rationalize other.shift })
+      elsif other.is_a?(Integer) or other.is_a?(Float)
+        self.class.new(map { |i| i.rationalize other })
+      else
+        super
+      end
+    end
+    
+    # 
+    # wector.round
+    # 
+    # Arguments:
+    #   other: (Array)
+    # 
+    def round(other)
+      if other.is_a? Array
+        raise "Incorrect Dimensions" unless self.size == other.size
+        other = other.dup
+        self.class.new(map { |i| i.round other.shift })
+      elsif other.is_a?(Integer) or other.is_a?(Float)
+        self.class.new(map { |i| i.round other })
+      else
+        super
+      end
+    end
+    
+    
+    # 
+    # wector.abs2
+    # 
+    def abs2
+      self.class.new(map { |i| i.abs2 })
+    end
+    
+    # 
+    # wector.arg
+    # 
+    def arg
+      self.class.new(map { |i| i.arg })
+    end
+    
+    # 
+    # wector.angle
+    # 
+    def angle
+      self.class.new(map { |i| i.angle })
+    end
+    
+    # 
+    # wector.conj
+    # 
+    def conj
+      self.class.new(map { |i| i.conj })
+    end
+    
+    # 
+    # wector.conjugate
+    # 
+    def conjugate
+      self.class.new(map { |i| i.conjugate })
+    end
+    
+    # 
+    # wector.denominator
+    # 
+    def denominator
+      self.class.new(map { |i| i.denominator })
+    end
+    
+    # 
+    # wector.imag
+    # 
+    def imag
+      self.class.new(map { |i| i.imag })
+    end
+    
+    # 
+    # wector.imaginary
+    # 
+    def imaginary
+      self.class.new(map { |i| i.imaginary })
+    end
+    
+    # 
+    # wector.magnitude
+    # 
+    def magnitude
+      self.class.new(map { |i| i.magnitude })
+    end
+    
+    # 
+    # wector.numerator
+    # 
+    def numerator
+      self.class.new(map { |i| i.numerator })
+    end
+    
+    # 
+    # wector.phase
+    # 
+    def phase
+      self.class.new(map { |i| i.phase })
+    end
+    
+    # 
+    # wector.polar
+    # 
+    def polar
+      self.class.new(map { |i| i.polar })
+    end
+    
+    # 
+    # wector.real
+    # 
+    def real
+      self.class.new(map { |i| i.real })
+    end
+    
+    # 
+    # wector.real?
+    # 
+    def real?
+      self.class.new(map { |i| i.real? })
+    end
+    
+    # 
+    # wector.rect
+    # 
+    def rect
+      self.class.new(map { |i| i.rect })
+    end
+    
+  end
 end
 
 # Add interface to convert arrays to vectors

data/src/build.rb

@@ -5,14 +5,21 @@ operator_methods = [
 ]
 
 comparison_methods = [
-	:modulo, :coerce, :div, :divmod, :eql?, :fdiv, :gcd, :gcdlcm, :lcm, :quo,
-	:rationalize, :remainder, :round
+	:modulo, :coerce, :div, :divmod, :eql?, :fdiv, :quo, :remainder
 ]
 
 transform_methods = [
-	:ceil, :abs, :abs2, :magnitude, :arg, :angle, :phase, :conj, :conjugate,
-	:denominator, :even?, :floor, :imag, :imaginary, :integer?, :nonzero?,
-	:odd?, :numerator, :polar, :pred, :real, :real?, :rect, :truncate, :zero?
+	:ceil, :abs, :even?, :floor, :integer?, :nonzero?,
+	:odd?, :pred, :truncate, :zero?
+]
+
+new_comparison_methods = [
+	:gcd, :gcdlcm, :lcm, :rationalize, :round
+]
+
+new_transform_methods = [
+	:abs2, :arg, :angle, :conj, :conjugate, :denominator, :imag, :imaginary,
+	:magnitude, :numerator, :phase, :polar, :real, :real?, :rect
 ]
 
 operator_tests = {
@@ -42,14 +49,16 @@ unary_operator_tests = {
 	plus: '+'
 }
 
-base_folder = File.join(File.dirname(__FILE__), '..')
+base_folder = File.dirname(__FILE__)
 
 # Generate lib/wector.rb
-File.open(File.join(base_folder, 'lib', 'wector.rb'), 'w') do |file|
-	file.write ERB.new(File.read('wector.erb'), 0, "%<>").result
+File.open(File.join(base_folder, '..', 'lib', 'wector.rb'), 'w') do |file|
+	template = File.read(File.join(base_folder, 'wector.erb'))
+	file.write ERB.new(template, 0, "%<>").result
 end
 
 # Generate tests/basic.rb
-File.open(File.join(base_folder, 'test', 'test_basic.rb'), 'w') do |file|
-	file.write ERB.new(File.read('test.erb'), 0, "%<>").result
+File.open(File.join(base_folder, '..', 'test', 'test_basic.rb'), 'w') do |file|
+	template = File.read(File.join(base_folder, 'test.erb'))
+	file.write ERB.new(template, 0, "%<>").result
 end

data/src/test.erb

@@ -34,4 +34,20 @@ class BasicTest < Test::Unit::TestCase
     assert_equal (nums.<%= name %>), nums.map { |v| v.<%= name %> }
   end
   <% end %>
+
+  # Only support 1.9+ features when available
+  v = RUBY_VERSION.split('.')
+  if v[0].to_i > 1 or v[1].to_i > 8
+    <% new_comparison_methods.each do |name| %>
+    def test_<%= name %>
+      nums = (1..100).to_a.to_wector
+      assert_equal (nums.<%= name %> nums), nums.map { |v| v.<%= name %> v }
+    end
+    <% end %><% new_transform_methods.each do |name| %>
+    def test_<%= name %>
+      nums = (1..100).to_a.to_wector
+      assert_equal (nums.<%= name %>), nums.map { |v| v.<%= name %> }
+    end
+    <% end %>
+  end
 end

data/src/wector.erb

@@ -70,6 +70,38 @@ class Wector < Array
     self.class.new(map { |i| i.<%= attr_name %> })
   end
   <% end %>
+
+  # Only support 1.9+ features when available
+  v = RUBY_VERSION.split('.')
+  if v[0].to_i > 1 or v[1].to_i > 8
+    <% new_comparison_methods.map { |v| v.to_s }.each do |attr_name| %>
+    # 
+    # wector.<%= attr_name %>
+    # 
+    # Arguments:
+    #   other: (Array)
+    # 
+    def <%= attr_name %>(other)
+      if other.is_a? Array
+        raise "Incorrect Dimensions" unless self.size == other.size
+        other = other.dup
+        self.class.new(map { |i| i.<%= attr_name %> other.shift })
+      elsif other.is_a?(Integer) or other.is_a?(Float)
+        self.class.new(map { |i| i.<%= attr_name %> other })
+      else
+        super
+      end
+    end
+    <% end %>
+    <% new_transform_methods.map { |v| v.to_s }.each do |attr_name| %>
+    # 
+    # wector.<%= attr_name %>
+    # 
+    def <%= attr_name %>
+      self.class.new(map { |i| i.<%= attr_name %> })
+    end
+    <% end %>
+  end
 end
 
 # Add interface to convert arrays to vectors

data/test/test_basic.rb

@@ -124,41 +124,16 @@ class BasicTest < Test::Unit::TestCase
     assert_equal (nums.fdiv nums), nums.map { |v| v.fdiv v }
   end
   
-  def test_gcd
-    nums = (1..100).to_a.to_wector
-    assert_equal (nums.gcd nums), nums.map { |v| v.gcd v }
-  end
-  
-  def test_gcdlcm
-    nums = (1..100).to_a.to_wector
-    assert_equal (nums.gcdlcm nums), nums.map { |v| v.gcdlcm v }
-  end
-  
-  def test_lcm
-    nums = (1..100).to_a.to_wector
-    assert_equal (nums.lcm nums), nums.map { |v| v.lcm v }
-  end
-  
   def test_quo
     nums = (1..100).to_a.to_wector
     assert_equal (nums.quo nums), nums.map { |v| v.quo v }
   end
   
-  def test_rationalize
-    nums = (1..100).to_a.to_wector
-    assert_equal (nums.rationalize nums), nums.map { |v| v.rationalize v }
-  end
-  
   def test_remainder
     nums = (1..100).to_a.to_wector
     assert_equal (nums.remainder nums), nums.map { |v| v.remainder v }
   end
   
-  def test_round
-    nums = (1..100).to_a.to_wector
-    assert_equal (nums.round nums), nums.map { |v| v.round v }
-  end
-  
   def test_ceil
     nums = (1..100).to_a.to_wector
     assert_equal (nums.ceil), nums.map { |v| v.ceil }
@@ -169,46 +144,6 @@ class BasicTest < Test::Unit::TestCase
     assert_equal (nums.abs), nums.map { |v| v.abs }
   end
   
-  def test_abs2
-    nums = (1..100).to_a.to_wector
-    assert_equal (nums.abs2), nums.map { |v| v.abs2 }
-  end
-  
-  def test_magnitude
-    nums = (1..100).to_a.to_wector
-    assert_equal (nums.magnitude), nums.map { |v| v.magnitude }
-  end
-  
-  def test_arg
-    nums = (1..100).to_a.to_wector
-    assert_equal (nums.arg), nums.map { |v| v.arg }
-  end
-  
-  def test_angle
-    nums = (1..100).to_a.to_wector
-    assert_equal (nums.angle), nums.map { |v| v.angle }
-  end
-  
-  def test_phase
-    nums = (1..100).to_a.to_wector
-    assert_equal (nums.phase), nums.map { |v| v.phase }
-  end
-  
-  def test_conj
-    nums = (1..100).to_a.to_wector
-    assert_equal (nums.conj), nums.map { |v| v.conj }
-  end
-  
-  def test_conjugate
-    nums = (1..100).to_a.to_wector
-    assert_equal (nums.conjugate), nums.map { |v| v.conjugate }
-  end
-  
-  def test_denominator
-    nums = (1..100).to_a.to_wector
-    assert_equal (nums.denominator), nums.map { |v| v.denominator }
-  end
-  
   def test_even?
     nums = (1..100).to_a.to_wector
     assert_equal (nums.even?), nums.map { |v| v.even? }
@@ -219,16 +154,6 @@ class BasicTest < Test::Unit::TestCase
     assert_equal (nums.floor), nums.map { |v| v.floor }
   end
   
-  def test_imag
-    nums = (1..100).to_a.to_wector
-    assert_equal (nums.imag), nums.map { |v| v.imag }
-  end
-  
-  def test_imaginary
-    nums = (1..100).to_a.to_wector
-    assert_equal (nums.imaginary), nums.map { |v| v.imaginary }
-  end
-  
   def test_integer?
     nums = (1..100).to_a.to_wector
     assert_equal (nums.integer?), nums.map { |v| v.integer? }
@@ -244,36 +169,11 @@ class BasicTest < Test::Unit::TestCase
     assert_equal (nums.odd?), nums.map { |v| v.odd? }
   end
   
-  def test_numerator
-    nums = (1..100).to_a.to_wector
-    assert_equal (nums.numerator), nums.map { |v| v.numerator }
-  end
-  
-  def test_polar
-    nums = (1..100).to_a.to_wector
-    assert_equal (nums.polar), nums.map { |v| v.polar }
-  end
-  
   def test_pred
     nums = (1..100).to_a.to_wector
     assert_equal (nums.pred), nums.map { |v| v.pred }
   end
   
-  def test_real
-    nums = (1..100).to_a.to_wector
-    assert_equal (nums.real), nums.map { |v| v.real }
-  end
-  
-  def test_real?
-    nums = (1..100).to_a.to_wector
-    assert_equal (nums.real?), nums.map { |v| v.real? }
-  end
-  
-  def test_rect
-    nums = (1..100).to_a.to_wector
-    assert_equal (nums.rect), nums.map { |v| v.rect }
-  end
-  
   def test_truncate
     nums = (1..100).to_a.to_wector
     assert_equal (nums.truncate), nums.map { |v| v.truncate }
@@ -284,4 +184,110 @@ class BasicTest < Test::Unit::TestCase
     assert_equal (nums.zero?), nums.map { |v| v.zero? }
   end
   
+
+  # Only support 1.9+ features when available
+  v = RUBY_VERSION.split('.')
+  if v[0].to_i > 1 or v[1].to_i > 8
+    
+    def test_gcd
+      nums = (1..100).to_a.to_wector
+      assert_equal (nums.gcd nums), nums.map { |v| v.gcd v }
+    end
+    
+    def test_gcdlcm
+      nums = (1..100).to_a.to_wector
+      assert_equal (nums.gcdlcm nums), nums.map { |v| v.gcdlcm v }
+    end
+    
+    def test_lcm
+      nums = (1..100).to_a.to_wector
+      assert_equal (nums.lcm nums), nums.map { |v| v.lcm v }
+    end
+    
+    def test_rationalize
+      nums = (1..100).to_a.to_wector
+      assert_equal (nums.rationalize nums), nums.map { |v| v.rationalize v }
+    end
+    
+    def test_round
+      nums = (1..100).to_a.to_wector
+      assert_equal (nums.round nums), nums.map { |v| v.round v }
+    end
+    
+    def test_abs2
+      nums = (1..100).to_a.to_wector
+      assert_equal (nums.abs2), nums.map { |v| v.abs2 }
+    end
+    
+    def test_arg
+      nums = (1..100).to_a.to_wector
+      assert_equal (nums.arg), nums.map { |v| v.arg }
+    end
+    
+    def test_angle
+      nums = (1..100).to_a.to_wector
+      assert_equal (nums.angle), nums.map { |v| v.angle }
+    end
+    
+    def test_conj
+      nums = (1..100).to_a.to_wector
+      assert_equal (nums.conj), nums.map { |v| v.conj }
+    end
+    
+    def test_conjugate
+      nums = (1..100).to_a.to_wector
+      assert_equal (nums.conjugate), nums.map { |v| v.conjugate }
+    end
+    
+    def test_denominator
+      nums = (1..100).to_a.to_wector
+      assert_equal (nums.denominator), nums.map { |v| v.denominator }
+    end
+    
+    def test_imag
+      nums = (1..100).to_a.to_wector
+      assert_equal (nums.imag), nums.map { |v| v.imag }
+    end
+    
+    def test_imaginary
+      nums = (1..100).to_a.to_wector
+      assert_equal (nums.imaginary), nums.map { |v| v.imaginary }
+    end
+    
+    def test_magnitude
+      nums = (1..100).to_a.to_wector
+      assert_equal (nums.magnitude), nums.map { |v| v.magnitude }
+    end
+    
+    def test_numerator
+      nums = (1..100).to_a.to_wector
+      assert_equal (nums.numerator), nums.map { |v| v.numerator }
+    end
+    
+    def test_phase
+      nums = (1..100).to_a.to_wector
+      assert_equal (nums.phase), nums.map { |v| v.phase }
+    end
+    
+    def test_polar
+      nums = (1..100).to_a.to_wector
+      assert_equal (nums.polar), nums.map { |v| v.polar }
+    end
+    
+    def test_real
+      nums = (1..100).to_a.to_wector
+      assert_equal (nums.real), nums.map { |v| v.real }
+    end
+    
+    def test_real?
+      nums = (1..100).to_a.to_wector
+      assert_equal (nums.real?), nums.map { |v| v.real? }
+    end
+    
+    def test_rect
+      nums = (1..100).to_a.to_wector
+      assert_equal (nums.rect), nums.map { |v| v.rect }
+    end
+    
+  end
 end

data/wector.gemspec

@@ -1,7 +1,7 @@
 # coding: utf-8
 Gem::Specification.new do |spec|
   spec.name          = "wector"
-  spec.version       = "0.0.3"
+  spec.version       = "0.0.4"
   spec.authors       = ["Stephen Belanger"]
   spec.email         = ["admin@stephenbelanger.com"]
   spec.description   = %q{

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wector
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Stephen Belanger
@@ -48,6 +48,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md