named_vector 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NGQwYzQ2NzYwOTQyNmM2NzUzODFlMWNhNjllODY2NDliYTAxNjZlZA==
+  data.tar.gz: !binary |-
+    MDk0MzM2ODNkNTAyOWY2YjNjZTg4MzZhNmYwODRjNTVmYjFmMTEyNQ==
+SHA512:
+  metadata.gz: !binary |-
+    ZTIxNTE0ODMwYWJiZGIxZjViNzNhMTFkNjI4MTRiM2YzYTNjOTJkM2VlMzI2
+    ZDYyMjFhOWIzNGEwZTE3NjQzNzM3NDAyODJlYzY2YWJkYTUzOTk5MzJhMzcy
+    Y2Q0NjQxM2JkN2RkOWE3OTIyYTNhZTczM2M0MWM3MmI1ZTIyYmQ=
+  data.tar.gz: !binary |-
+    YjFiNmVhNmI0NTRkNjhmYTdiY2YzMTVjMzJkY2I1OWMxZmJjYTQ3NzkyMTZm
+    OGFlNGFmMmY1YmFhNmM2ZDhmYjg2NDQyOWFlMjc0MTZiMzJlNDE0YmMwZjEx
+    YWYwNmQyYjlmNzY2ZDkzOTMyMWQ2OWRlNTFkMzA0MjNkMzVmNzk=

data/lib/named_vector.rb

@@ -0,0 +1,162 @@
+# coding: utf-8
+# @author Jonathan Raiman
+
+
+# Vectors with named dimensions. Infinite dimensional objects with simple vector calculus operations defined.
+class NamedVector 
+	attr_reader :keys
+	alias :dimensions :keys
+
+	# creates a new named vector
+	# @param dims [Hash<String,Fixnum>, Hash<Symbol,Fixnum>, Array<String>, Array<Symbol>] the dimensions to initialize the vectors with, either as a hash of assignments or simply the names of the dimensions.
+	def initialize(*dims)
+		@vector = Hash.new
+		@keys   = Set.new
+		if dims && dims.first
+			case dims.first
+			when Hash
+				hash = dims.first
+				hash.keys.each {|d| modify_dimension(d, hash[d])}
+			when String, Symbol, Fixnum
+				@keys = Set.new(dims.map {|i| i.to_s})
+				dims.each {|d| new_dimension(d)}
+			end
+		else
+			@keys = []
+		end
+	end
+
+	# Perform a dot product with another vector
+	# @param value [Hash, Fixnum, Float, NamedVector] the vector or scalar to multiply this vector with. Scalar multiplication is destructive.
+	def *(value)
+		case value
+		when Fixnum, Float  #scalar multiplication product
+			each_dimension {|i| @vector[i] = self[i]*value}
+		when NamedVector #dot product
+			NamedVector.dot_product(self, value)
+		when Hash #dot product
+			NamedVector.add_dimension_iterator(value)
+			NamedVector.dot_product(self,value)
+		else
+			raise TypeError, "#{value.class} cannot be coerced to NamedVector."
+		end
+	end
+
+	# adds a dimension iterator (iterate through the keys) to a Hash or NamedVector
+	# @param obj [Hash, NamedVector] the object to add the method to.
+	def self.add_dimension_iterator(obj)
+		obj.define_singleton_method(:each_dimension) do |&block|
+			self.keys.each do |key|
+				block.call(key)
+			end
+		end
+	end
+
+	# Perform a dot product with another vector
+	# @param value [Hash, NamedVector] the vector to multiply this vector with.
+	def dot_product(value)
+		NamedVector.dot_product(self, value)
+	end
+
+	# Perform a dot product with another vector
+	# @param a [Hash, NamedVector] the vector or scalar to multiply this vector with.
+	# @param b [Hash, NamedVector] the vector or scalar to multiply this vector with.
+	def self.dot_product(a, b)
+		sum    = 0.0
+		if a.keys.length < b.keys.length
+			a.each_dimension {|i| sum+=a[i]*b[i]}
+		else
+			b.each_dimension {|i| sum+=b[i]*a[i]}
+		end
+		sum
+	end
+
+	# iterates through each dimension of a vector
+	def each_dimension
+		@keys.each do |key|
+			yield(key)
+		end
+	end
+
+	# fetches the value at the dimension specified
+	# @param key [Symbol, String] the dimension requested
+	def [](key)
+		@vector.fetch(key.to_s,0.0)
+	end
+
+	def modify_dimension(key,value)
+		new_dimension(key.to_s)
+		@vector[key.to_s] = value
+	end
+
+	# assigns a value at the dimension specified
+	# @param key [Symbol, String] the dimension requested
+	# @param value [Fixnum, Float] the assignment for this dimension
+	def []=(key,value)
+		modify_dimension(key,value)
+	end
+
+	def method_missing(mid, *args) # :nodoc:
+		mname = mid.id2name
+		len = args.length
+		if mname.chomp!('=')
+			if len != 1
+				raise ArgumentError, "wrong number of arguments (#{len} for 1)", caller(1)
+			end
+			modify_dimension(mname, args[0])
+		elsif len == 0
+			@vector.fetch(mname,0.0)
+		else
+			raise NoMethodError, "undefined method `#{mid}' for #{self}", caller(1)
+		end
+	end
+
+	def new_dimension(name)
+		sym_name = name.to_sym
+		unless respond_to?(sym_name)
+			@keys << name
+			define_singleton_method(sym_name) { @vector.fetch(name,0.0) }
+			define_singleton_method("#{sym_name}=") { |x| @vector[name] = x }
+		end
+		name
+	end
+	protected :new_dimension
+
+	# the squared Euclidean norm of a vector
+	def squared_norm
+		norm    = 0.0
+		each_dimension {|i| norm+=self[i]**2}
+		norm
+	end
+
+	# the Euclidean norm of a vector
+	def norm
+		Math.sqrt(squared_norm)
+	end
+
+	# normalizes the vector destructively.
+	def normalize
+		current_norm = norm
+		if current_norm > 0 then self*(1.0/current_norm) end
+	end
+
+	# Mongo conversion
+	def to_mongo
+		{"keys"=> @keys, "dimensions"=> @keys.map {|i| self[i]}}
+	end
+
+	# Mongo retrieval
+	# @param doc [BSON::OrderedHash] the mongo document to retrieve the vector from.
+	def self.from_mongo(doc)
+		hash = {}
+		doc["keys"].each_with_index do |k, index|
+			hash[k] = doc["dimensions"][index]
+		end
+		self.new hash
+	end
+
+	private :new_dimension
+	private :method_missing
+	private :modify_dimension
+
+end

data/specs/initialization.rb

@@ -0,0 +1,56 @@
+require './lib/named_vector.rb'
+describe 'Initialization' do
+	it 'should have all the dimensions given in the initilization' do
+		dimensions = ["x","y"]
+		vector = NamedVector.new(*dimensions)
+		vector.dimensions.should include(*dimensions)
+		dimensions.each do |dim|
+			vector.should respond_to(dim.to_sym).with(0).arguments
+		end
+	end
+
+	it 'should initialize from a hash as well' do
+		hash_vector = {"x" => 1.0, "y" => 2.0, "z" => 0.0}
+		vector = NamedVector.new(hash_vector)
+		hash_vector.keys.should eql vector.keys.to_a
+		hash_vector.keys.each do |key|
+			vector.should respond_to(key.to_sym).with(0).arguments
+			vector[key].should eql hash_vector[key]
+		end
+	end
+
+	it 'should allow dot products between vectors' do
+		dimensions = ["x","y"]
+		vectorA = NamedVector.new(:x => 1, :y => 1)
+		vectorB = NamedVector.new(:x => 1)
+		(vectorA*vectorB).should eql 1.0
+	end
+
+	it 'should allow dot products between mismatched vectors' do
+		vectorA = NamedVector.new(           "x" => 0, "z" => 2)
+		vectorB = NamedVector.new("b" => 10,           "z" => 1)
+		vectorA.x = 0
+		vectorB.z = 1
+		vectorA.z = 2
+		vectorB.a = 10
+		(vectorA*vectorB).should eql 2.0
+	end
+
+	it 'should allow dot products between vectors and hashes' do
+		vectorA = NamedVector.new("x","y","z")
+		vectorB = {:x => 1, :y => 2, :z => 3}
+		vectorA.x = 1
+		vectorA.y = 1
+		vectorA.z = 1
+		(vectorA*vectorB).should eql 6.0
+	end
+
+	it 'should normalize vectors' do
+		vector = NamedVector.new("x","y","z")
+		vector.x = 1
+		vector.y = 1
+		vector.z = 1
+		vector.normalize
+		vector.norm.should be_within(0.01).of 1.0
+	end
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: named_vector
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jonathan Raiman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-28 00:00:00.000000000 Z
+dependencies: []
+description: Vectors with named dimensions.
+email: jraiman@mit.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/named_vector.rb
+- specs/initialization.rb
+homepage: http://github.org/JonathanRaiman/named_vector
+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.1.10
+signing_key: 
+specification_version: 4
+summary: Vectors with named dimensions.
+test_files:
+- specs/initialization.rb
+has_rdoc: yard