wector 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3ad1ed315bccca62b4e2e13998f1b6650e57568a
-  data.tar.gz: 84d317bc05507b498d6600563e3b7b389fb2feac
+  metadata.gz: af75df7e08d5f55b00bab2d8d60045b3dba237a6
+  data.tar.gz: f91fcb8821ba7bc30342c9c299f7a70f3c32c544
 SHA512:
-  metadata.gz: a869f2c0b7a53e01e15649dd5d8c670f55dcf36cbe0bac907ef8e8ba05f73832dfbb95b51bd31d7e0f6b502281f42b9ad9980b3320acebc2f6d323d96602898f
-  data.tar.gz: 79aa29c909682638bb53c57df5402661c9a006695c23c5e1de0fc246498ae3d1e6b12adeea587194c341dc057f485bbf8133501b561bd9efeb31e4e7c6b5df1f
+  metadata.gz: dd1090d7821a26e93789b20d2e9b45559d968caf97bbe2a981d7c5a6d130fa63cf509fcf1301a24754ddca1181ee9022031b596680827bb566ae691c04889fe7
+  data.tar.gz: d14805939d4f2d016d3b2ddfb0d6364e6198c5b6789d2cc48c00c35de21b20756fcc3e200dfcb9b4d110a1e3bf69a43afc26ce463a88000687b132e6125a36de

data/Rakefile

@@ -1 +1,9 @@
 require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/lib/wector.rb

@@ -1,62 +1,678 @@
 class Wector < Array
-	def [](*args)
-		args.each do |arg|
-			raise "Non-numeric item" unless arg.is_a?(Integer) or arg.is_a?(Float)
-			unshift arg
-		end
-	end
-end
-
-# Comparison operators
-[
-	:*,:+,:/,:-,:**,:%,:^,:==,:===,:<=>,:>,:>=,:<,:<=,:~,:&,:|
-].map { |v| v.to_s }.each do |attr_name|
-  Wector.class_eval %Q{
-	  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
-
-# Comparison methods
-[
-	:-@, :+@, :modulo, :coerce, :div, :divmod, :eql?, :fdiv, :quo, :remainder,
-	:round
-].map { |v| v.to_s }.each do |attr_name|
-  Wector.class_eval %Q{
-	  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
+  def [](*args)
+    args.each do |arg|
+      raise "Non-numeric item" unless arg.is_a?(Integer) or arg.is_a?(Float)
+      unshift arg
+    end
+  end
 
-# Transform methods
-[
-	:ceil, :abs, :abs2, :magnitude, :arg, :angle, :phase, :conj, :conjugate,
-	:denominator, :floor, :imag, :imaginary, :integer?, :nonzero?, :numerator,
-	:polar, :real, :real?, :rect, :to_c, :to_int, :truncate, :zero?
-].map { |v| v.to_s }.each do |attr_name|
-  Wector.class_eval %Q{
-	  def #{attr_name}
-	    self.class.new(map { |i| i.#{attr_name} })
-	  end
-  }
+  # 
+  # wector.~
+  # 
+  def ~
+    self.class.new(map { |i| ~i })
+  end
+  
+  # 
+  # wector.-
+  # 
+  def -@
+    self.class.new(map { |i| -i })
+  end
+  
+  # 
+  # wector.+
+  # 
+  def +@
+    self.class.new(map { |i| +i })
+  end
+  
+  # Operators
+  # 
+  # wector.*
+  # 
+  # Arguments:
+  #   other: (Array)
+  # 
+  def *(other)
+    if other.is_a? Array
+      raise "Incorrect Dimensions" unless self.size == other.size
+      other = other.dup
+      self.class.new(map { |i| i * other.shift })
+    elsif other.is_a?(Integer) or other.is_a?(Float)
+      self.class.new(map { |i| i * other })
+    else
+      super
+    end
+  end
+  
+  # 
+  # wector.+
+  # 
+  # Arguments:
+  #   other: (Array)
+  # 
+  def +(other)
+    if other.is_a? Array
+      raise "Incorrect Dimensions" unless self.size == other.size
+      other = other.dup
+      self.class.new(map { |i| i + other.shift })
+    elsif other.is_a?(Integer) or other.is_a?(Float)
+      self.class.new(map { |i| i + other })
+    else
+      super
+    end
+  end
+  
+  # 
+  # wector./
+  # 
+  # Arguments:
+  #   other: (Array)
+  # 
+  def /(other)
+    if other.is_a? Array
+      raise "Incorrect Dimensions" unless self.size == other.size
+      other = other.dup
+      self.class.new(map { |i| i / other.shift })
+    elsif other.is_a?(Integer) or other.is_a?(Float)
+      self.class.new(map { |i| i / other })
+    else
+      super
+    end
+  end
+  
+  # 
+  # wector.-
+  # 
+  # Arguments:
+  #   other: (Array)
+  # 
+  def -(other)
+    if other.is_a? Array
+      raise "Incorrect Dimensions" unless self.size == other.size
+      other = other.dup
+      self.class.new(map { |i| i - other.shift })
+    elsif other.is_a?(Integer) or other.is_a?(Float)
+      self.class.new(map { |i| i - other })
+    else
+      super
+    end
+  end
+  
+  # 
+  # wector.**
+  # 
+  # Arguments:
+  #   other: (Array)
+  # 
+  def **(other)
+    if other.is_a? Array
+      raise "Incorrect Dimensions" unless self.size == other.size
+      other = other.dup
+      self.class.new(map { |i| i ** other.shift })
+    elsif other.is_a?(Integer) or other.is_a?(Float)
+      self.class.new(map { |i| i ** other })
+    else
+      super
+    end
+  end
+  
+  # 
+  # wector.%
+  # 
+  # Arguments:
+  #   other: (Array)
+  # 
+  def %(other)
+    if other.is_a? Array
+      raise "Incorrect Dimensions" unless self.size == other.size
+      other = other.dup
+      self.class.new(map { |i| i % other.shift })
+    elsif other.is_a?(Integer) or other.is_a?(Float)
+      self.class.new(map { |i| i % other })
+    else
+      super
+    end
+  end
+  
+  # 
+  # wector.==
+  # 
+  # Arguments:
+  #   other: (Array)
+  # 
+  def ==(other)
+    if other.is_a? Array
+      raise "Incorrect Dimensions" unless self.size == other.size
+      other = other.dup
+      self.class.new(map { |i| i == other.shift })
+    elsif other.is_a?(Integer) or other.is_a?(Float)
+      self.class.new(map { |i| i == other })
+    else
+      super
+    end
+  end
+  
+  # 
+  # wector.===
+  # 
+  # Arguments:
+  #   other: (Array)
+  # 
+  def ===(other)
+    if other.is_a? Array
+      raise "Incorrect Dimensions" unless self.size == other.size
+      other = other.dup
+      self.class.new(map { |i| i === other.shift })
+    elsif other.is_a?(Integer) or other.is_a?(Float)
+      self.class.new(map { |i| i === other })
+    else
+      super
+    end
+  end
+  
+  # 
+  # wector.<=>
+  # 
+  # Arguments:
+  #   other: (Array)
+  # 
+  def <=>(other)
+    if other.is_a? Array
+      raise "Incorrect Dimensions" unless self.size == other.size
+      other = other.dup
+      self.class.new(map { |i| i <=> other.shift })
+    elsif other.is_a?(Integer) or other.is_a?(Float)
+      self.class.new(map { |i| i <=> other })
+    else
+      super
+    end
+  end
+  
+  # 
+  # wector.>
+  # 
+  # Arguments:
+  #   other: (Array)
+  # 
+  def >(other)
+    if other.is_a? Array
+      raise "Incorrect Dimensions" unless self.size == other.size
+      other = other.dup
+      self.class.new(map { |i| i > other.shift })
+    elsif other.is_a?(Integer) or other.is_a?(Float)
+      self.class.new(map { |i| i > other })
+    else
+      super
+    end
+  end
+  
+  # 
+  # wector.>=
+  # 
+  # Arguments:
+  #   other: (Array)
+  # 
+  def >=(other)
+    if other.is_a? Array
+      raise "Incorrect Dimensions" unless self.size == other.size
+      other = other.dup
+      self.class.new(map { |i| i >= other.shift })
+    elsif other.is_a?(Integer) or other.is_a?(Float)
+      self.class.new(map { |i| i >= other })
+    else
+      super
+    end
+  end
+  
+  # 
+  # wector.<
+  # 
+  # Arguments:
+  #   other: (Array)
+  # 
+  def <(other)
+    if other.is_a? Array
+      raise "Incorrect Dimensions" unless self.size == other.size
+      other = other.dup
+      self.class.new(map { |i| i < other.shift })
+    elsif other.is_a?(Integer) or other.is_a?(Float)
+      self.class.new(map { |i| i < other })
+    else
+      super
+    end
+  end
+  
+  # 
+  # wector.<=
+  # 
+  # Arguments:
+  #   other: (Array)
+  # 
+  def <=(other)
+    if other.is_a? Array
+      raise "Incorrect Dimensions" unless self.size == other.size
+      other = other.dup
+      self.class.new(map { |i| i <= other.shift })
+    elsif other.is_a?(Integer) or other.is_a?(Float)
+      self.class.new(map { |i| i <= other })
+    else
+      super
+    end
+  end
+  
+  
+  # 
+  # wector.modulo
+  # 
+  # Arguments:
+  #   other: (Array)
+  # 
+  def modulo(other)
+    if other.is_a? Array
+      raise "Incorrect Dimensions" unless self.size == other.size
+      other = other.dup
+      self.class.new(map { |i| i.modulo other.shift })
+    elsif other.is_a?(Integer) or other.is_a?(Float)
+      self.class.new(map { |i| i.modulo other })
+    else
+      super
+    end
+  end
+  
+  # 
+  # wector.coerce
+  # 
+  # Arguments:
+  #   other: (Array)
+  # 
+  def coerce(other)
+    if other.is_a? Array
+      raise "Incorrect Dimensions" unless self.size == other.size
+      other = other.dup
+      self.class.new(map { |i| i.coerce other.shift })
+    elsif other.is_a?(Integer) or other.is_a?(Float)
+      self.class.new(map { |i| i.coerce other })
+    else
+      super
+    end
+  end
+  
+  # 
+  # wector.div
+  # 
+  # Arguments:
+  #   other: (Array)
+  # 
+  def div(other)
+    if other.is_a? Array
+      raise "Incorrect Dimensions" unless self.size == other.size
+      other = other.dup
+      self.class.new(map { |i| i.div other.shift })
+    elsif other.is_a?(Integer) or other.is_a?(Float)
+      self.class.new(map { |i| i.div other })
+    else
+      super
+    end
+  end
+  
+  # 
+  # wector.divmod
+  # 
+  # Arguments:
+  #   other: (Array)
+  # 
+  def divmod(other)
+    if other.is_a? Array
+      raise "Incorrect Dimensions" unless self.size == other.size
+      other = other.dup
+      self.class.new(map { |i| i.divmod other.shift })
+    elsif other.is_a?(Integer) or other.is_a?(Float)
+      self.class.new(map { |i| i.divmod other })
+    else
+      super
+    end
+  end
+  
+  # 
+  # wector.eql?
+  # 
+  # Arguments:
+  #   other: (Array)
+  # 
+  def eql?(other)
+    if other.is_a? Array
+      raise "Incorrect Dimensions" unless self.size == other.size
+      other = other.dup
+      self.class.new(map { |i| i.eql? other.shift })
+    elsif other.is_a?(Integer) or other.is_a?(Float)
+      self.class.new(map { |i| i.eql? other })
+    else
+      super
+    end
+  end
+  
+  # 
+  # wector.fdiv
+  # 
+  # Arguments:
+  #   other: (Array)
+  # 
+  def fdiv(other)
+    if other.is_a? Array
+      raise "Incorrect Dimensions" unless self.size == other.size
+      other = other.dup
+      self.class.new(map { |i| i.fdiv other.shift })
+    elsif other.is_a?(Integer) or other.is_a?(Float)
+      self.class.new(map { |i| i.fdiv other })
+    else
+      super
+    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
+  # 
+  # Arguments:
+  #   other: (Array)
+  # 
+  def quo(other)
+    if other.is_a? Array
+      raise "Incorrect Dimensions" unless self.size == other.size
+      other = other.dup
+      self.class.new(map { |i| i.quo other.shift })
+    elsif other.is_a?(Integer) or other.is_a?(Float)
+      self.class.new(map { |i| i.quo 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.remainder
+  # 
+  # Arguments:
+  #   other: (Array)
+  # 
+  def remainder(other)
+    if other.is_a? Array
+      raise "Incorrect Dimensions" unless self.size == other.size
+      other = other.dup
+      self.class.new(map { |i| i.remainder other.shift })
+    elsif other.is_a?(Integer) or other.is_a?(Float)
+      self.class.new(map { |i| i.remainder 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.ceil
+  # 
+  def ceil
+    self.class.new(map { |i| i.ceil })
+  end
+  
+  # 
+  # wector.abs
+  # 
+  def abs
+    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?
+  # 
+  def even?
+    self.class.new(map { |i| i.even? })
+  end
+  
+  # 
+  # wector.floor
+  # 
+  def floor
+    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?
+  # 
+  def integer?
+    self.class.new(map { |i| i.integer? })
+  end
+  
+  # 
+  # wector.nonzero?
+  # 
+  def nonzero?
+    self.class.new(map { |i| i.nonzero? })
+  end
+  
+  # 
+  # wector.odd?
+  # 
+  def odd?
+    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
+  # 
+  def pred
+    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
+  # 
+  def truncate
+    self.class.new(map { |i| i.truncate })
+  end
+  
+  # 
+  # wector.zero?
+  # 
+  def zero?
+    self.class.new(map { |i| i.zero? })
+  end
+  
 end
 
 # Add interface to convert arrays to vectors

data/src/build.rb

@@ -0,0 +1,55 @@
+require 'erb'
+
+operator_methods = [
+	:*,:+,:/,:-,:**,:%,:==,:===,:<=>,:>,:>=,:<,:<=
+]
+
+comparison_methods = [
+	:modulo, :coerce, :div, :divmod, :eql?, :fdiv, :gcd, :gcdlcm, :lcm, :quo,
+	:rationalize, :remainder, :round
+]
+
+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?
+]
+
+operator_tests = {
+	# Basic math
+	multiplication: '*',
+	subtraction: '-',
+	addition: '+',
+	division: '/',
+
+	# Complex math
+	exponent: '**',
+	modulus: '%',
+
+	# Comparisons
+	greater: '>',
+	lesser: '<',
+	equal: '==',
+	strict_equal: '===',
+	greater_or_equal: '>=',
+	lesser_or_equal: '<=',
+	greater_equal_or_lesser: '<=>'
+}
+
+unary_operator_tests = {
+	inversion: '~',
+	minus: '-',
+	plus: '+'
+}
+
+base_folder = File.join(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
+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
+end

data/src/test.erb

@@ -0,0 +1,37 @@
+require 'test/unit'
+require 'wector'
+
+class BasicTest < Test::Unit::TestCase
+
+  def test_construction_and_conversion
+    assert_equal Wector.new([1,2,3]), [1,2,3].to_wector
+  end
+
+  def test_insertion
+    foo = [1,2,3].to_wector
+    foo[3] = 4
+    foo << 5
+    assert_equal foo, [1,2,3,4,5]
+  end
+  <% operator_tests.each do |name, op| %>
+  def test_<%= name %>
+    nums = (1..100).to_a.to_wector
+    assert_equal (nums <%= op %> nums), nums.map { |v| v <%= op %> v }
+  end
+  <% end %><% unary_operator_tests.each do |name, op| %>
+  def test_<%= name %>
+    nums = (1..100).to_a.to_wector
+    assert_equal (<%= op %>nums), nums.map { |v| <%= op %>v }
+  end
+  <% end %><% 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 %><% 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

data/src/wector.erb

@@ -0,0 +1,80 @@
+class Wector < Array
+
+  # 
+  # wector.[]
+  # 
+  def [](*args)
+    args.each do |arg|
+      raise "Non-numeric item" unless arg.is_a?(Integer) or arg.is_a?(Float)
+      unshift arg
+    end
+  end
+
+  # 
+  # wector.~
+  # 
+  def ~
+    self.class.new(map { |i| ~i })
+  end
+  <% [:-, :+].map { |v| v.to_s }.each do |attr_name| %>
+  # 
+  # wector.<%= attr_name %>
+  # 
+  def <%= attr_name %>@
+    self.class.new(map { |i| <%= attr_name %>i })
+  end
+  <% end %>
+  # Operators<% operator_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 %>
+  <% 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 %>
+  <% 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
+
+# Add interface to convert arrays to vectors
+class Array
+  def to_wector
+    Wector.new(self)
+  end
+end

data/test/test_basic.rb

@@ -0,0 +1,287 @@
+require 'test/unit'
+require 'wector'
+
+class BasicTest < Test::Unit::TestCase
+
+  def test_construction_and_conversion
+    assert_equal Wector.new([1,2,3]), [1,2,3].to_wector
+  end
+
+  def test_insertion
+    foo = [1,2,3].to_wector
+    foo[3] = 4
+    foo << 5
+    assert_equal foo, [1,2,3,4,5]
+  end
+  
+  def test_multiplication
+    nums = (1..100).to_a.to_wector
+    assert_equal (nums * nums), nums.map { |v| v * v }
+  end
+  
+  def test_subtraction
+    nums = (1..100).to_a.to_wector
+    assert_equal (nums - nums), nums.map { |v| v - v }
+  end
+  
+  def test_addition
+    nums = (1..100).to_a.to_wector
+    assert_equal (nums + nums), nums.map { |v| v + v }
+  end
+  
+  def test_division
+    nums = (1..100).to_a.to_wector
+    assert_equal (nums / nums), nums.map { |v| v / v }
+  end
+  
+  def test_exponent
+    nums = (1..100).to_a.to_wector
+    assert_equal (nums ** nums), nums.map { |v| v ** v }
+  end
+  
+  def test_modulus
+    nums = (1..100).to_a.to_wector
+    assert_equal (nums % nums), nums.map { |v| v % v }
+  end
+  
+  def test_greater
+    nums = (1..100).to_a.to_wector
+    assert_equal (nums > nums), nums.map { |v| v > v }
+  end
+  
+  def test_lesser
+    nums = (1..100).to_a.to_wector
+    assert_equal (nums < nums), nums.map { |v| v < v }
+  end
+  
+  def test_equal
+    nums = (1..100).to_a.to_wector
+    assert_equal (nums == nums), nums.map { |v| v == v }
+  end
+  
+  def test_strict_equal
+    nums = (1..100).to_a.to_wector
+    assert_equal (nums === nums), nums.map { |v| v === v }
+  end
+  
+  def test_greater_or_equal
+    nums = (1..100).to_a.to_wector
+    assert_equal (nums >= nums), nums.map { |v| v >= v }
+  end
+  
+  def test_lesser_or_equal
+    nums = (1..100).to_a.to_wector
+    assert_equal (nums <= nums), nums.map { |v| v <= v }
+  end
+  
+  def test_greater_equal_or_lesser
+    nums = (1..100).to_a.to_wector
+    assert_equal (nums <=> nums), nums.map { |v| v <=> v }
+  end
+  
+  def test_inversion
+    nums = (1..100).to_a.to_wector
+    assert_equal (~nums), nums.map { |v| ~v }
+  end
+  
+  def test_minus
+    nums = (1..100).to_a.to_wector
+    assert_equal (-nums), nums.map { |v| -v }
+  end
+  
+  def test_plus
+    nums = (1..100).to_a.to_wector
+    assert_equal (+nums), nums.map { |v| +v }
+  end
+  
+  def test_modulo
+    nums = (1..100).to_a.to_wector
+    assert_equal (nums.modulo nums), nums.map { |v| v.modulo v }
+  end
+  
+  def test_coerce
+    nums = (1..100).to_a.to_wector
+    assert_equal (nums.coerce nums), nums.map { |v| v.coerce v }
+  end
+  
+  def test_div
+    nums = (1..100).to_a.to_wector
+    assert_equal (nums.div nums), nums.map { |v| v.div v }
+  end
+  
+  def test_divmod
+    nums = (1..100).to_a.to_wector
+    assert_equal (nums.divmod nums), nums.map { |v| v.divmod v }
+  end
+  
+  def test_eql?
+    nums = (1..100).to_a.to_wector
+    assert_equal (nums.eql? nums), nums.map { |v| v.eql? v }
+  end
+  
+  def test_fdiv
+    nums = (1..100).to_a.to_wector
+    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 }
+  end
+  
+  def test_abs
+    nums = (1..100).to_a.to_wector
+    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? }
+  end
+  
+  def test_floor
+    nums = (1..100).to_a.to_wector
+    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? }
+  end
+  
+  def test_nonzero?
+    nums = (1..100).to_a.to_wector
+    assert_equal (nums.nonzero?), nums.map { |v| v.nonzero? }
+  end
+  
+  def test_odd?
+    nums = (1..100).to_a.to_wector
+    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 }
+  end
+  
+  def test_zero?
+    nums = (1..100).to_a.to_wector
+    assert_equal (nums.zero?), nums.map { |v| v.zero? }
+  end
+  
+end

data/wector.gemspec

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wector
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Stephen Belanger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-03 00:00:00.000000000 Z
+date: 2013-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,6 +53,10 @@ files:
 - README.md
 - Rakefile
 - lib/wector.rb
+- src/build.rb
+- src/test.erb
+- src/wector.erb
+- test/test_basic.rb
 - wector.gemspec
 homepage: ''
 licenses:
@@ -78,4 +82,5 @@ rubygems_version: 2.0.0
 signing_key: 
 specification_version: 4
 summary: Wector makes vector math dead simple
-test_files: []
+test_files:
+- test/test_basic.rb