hal4r 0.0.1

data/ChangeLog

@@ -0,0 +1,11 @@
+# markup: rd
+
+= Revision history for hal4r
+
+== 0.0.1 [2015-07-23]
+
+* First release.
+
+== 0.0.0 [2015-07-15]
+
+* Birthday :-)

data/README

@@ -0,0 +1,49 @@
+= hal4r - Hyperspace analogue to language for Ruby
+
+== VERSION
+
+This documentation refers to hal4r version 0.0.1.
+
+
+== DESCRIPTION
+
+HAL[https://en.wikipedia.org/wiki/Hyperspace_Analogue_to_Language] processing
+for Ruby. Requires {GSL bindings}[https://blackwinter.github.com/rb-gsl] for
+the heavy lifting.
+
+
+== LINKS
+
+Documentation:: https://blackwinter.github.com/hal4r
+Source code::   https://github.com/blackwinter/hal4r
+RubyGem::       https://rubygems.org/gems/hal4r
+Travis CI::     https://travis-ci.org/blackwinter/hal4r
+
+
+== LITERATURE
+
+* Lund, K., Burgess, C. & Atchley, R. A. (1995). "Semantic and associative priming in high-dimensional semantic space". <i>Proceedings of the seventeenth annual conference of the Cognitive Science Society</i>, 660–665. ISBN:0-8058-2159-7[https://books.google.de/books?id=CSU_Mj07G7UC].
+* Lund, K.; Burgess, C. (1996). "Producing high-dimensional semantic spaces from lexical co-occurrence". <i>Behavior Research Methods, Instruments & Computers</i> 28 (2): 203–208. doi:10.3758/bf03204766[https://dx.doi.org/10.3758%2Fbf03204766].
+
+
+== AUTHORS
+
+* Jens Wille <mailto:jens.wille@gmail.com>
+
+
+== LICENSE AND COPYRIGHT
+
+Copyright (C) 2015 Jens Wille
+
+hal4r is free software: you can redistribute it and/or modify it
+under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at your
+option) any later version.
+
+hal4r is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with hal4r. If not, see <http://www.gnu.org/licenses/>.

data/Rakefile

@@ -0,0 +1,23 @@
+require_relative 'lib/hal4r/version'
+
+begin
+  require 'hen'
+
+  Hen.lay! {{
+    gem: {
+      name:         %q{hal4r},
+      version:      Hal4R::VERSION,
+      summary:      %q{Hyperspace analogue to language for Ruby.},
+      description:  %q{HAL processing for Ruby.},
+      author:       %q{Jens Wille},
+      email:        %q{jens.wille@gmail.com},
+      license:      %q{AGPL-3.0},
+      homepage:     :blackwinter,
+      dependencies: %w[rb-gsl],
+
+      required_ruby_version: '>= 1.9.3'
+    }
+  }}
+rescue LoadError => err
+  warn "Please install the `hen' gem. (#{err})"
+end

data/bin/hal4r

@@ -0,0 +1,11 @@
+#! /usr/bin/env ruby
+
+require 'hal4r'
+
+abort "Usage: #{$0} <words...> [<window>]" if ARGV.empty? && $stdin.tty?
+
+window_size = ARGV.pop.to_i if ARGV.last =~ /\A\d+\z/
+
+terms = ARGV.empty? ? $stdin.readlines.flat_map(&:split).grep(/\w/) : ARGV
+
+puts Hal4R.new(terms, window_size)

data/lib/hal4r.rb

@@ -0,0 +1,157 @@
+#--
+###############################################################################
+#                                                                             #
+# hal4r -- Hyperspace analogue to language for Ruby                           #
+#                                                                             #
+# Copyright (C) 2015 Jens Wille                                               #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@gmail.com>                                       #
+#                                                                             #
+# hal4r is free software; you can redistribute it and/or modify it under the  #
+# terms of the GNU Affero General Public License as published by the Free     #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# hal4r is distributed in the hope that it will be useful, but WITHOUT ANY    #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for     #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU Affero General Public License    #
+# along with hal4r. If not, see <http://www.gnu.org/licenses/>.               #
+#                                                                             #
+###############################################################################
+#++
+
+require 'forwardable'
+require 'nuggets/hash/idmap'
+
+class Hal4R
+
+  include Enumerable
+
+  extend Forwardable
+
+  DEFAULT_WINDOW_SIZE = 10
+
+  def_delegator :@idmap, :keys, :terms
+
+  def_delegators :@idmap, :size, :empty?
+
+  def initialize(terms = [], window_size = nil)
+    reset(window_size)
+    add(terms)
+  end
+
+  attr_accessor :window_size
+
+  def reset(window_size = window_size())
+    @idmap, @matrix, @window = Hash.idmap(-1), Matrix.new,
+      Array.new(@window_size = window_size || DEFAULT_WINDOW_SIZE)
+
+    self
+  end
+
+  def <<(term)
+    row = @matrix.get(term_index = @idmap[term])
+
+    @window.each_with_index { |index, weight|
+      row[index] += weight + 1 if index
+    }.insert(-1, term_index).shift
+
+    self
+  end
+
+  def add(terms)
+    terms.each { |term| self << term }
+    self
+  end
+
+  def vector(term, norm = false)
+    vector_i(@idmap.fetch(term), norm)
+  end
+
+  alias_method :[], :vector
+
+  def norm(term)
+    vector(term, true)
+  end
+
+  def each_vector(norm = false)
+    return enum_for(:each_vector, norm) unless block_given?
+
+    @idmap.each_value { |index| yield vector_i(index, norm).to_a }
+
+    self
+  end
+
+  def each_norm(&block)
+    each_vector(true, &block)
+  end
+
+  alias_method :each, :each_norm
+
+  def each_distance(norm = true, dimension = 2)
+    return enum_for(:each_distance, norm, dimension) unless block_given?
+
+    terms.combination(2) { |t| yield *t.sort!, minkowski(*t, dimension, norm) }
+
+    self
+  end
+
+  def related(term, num = window_size, dimension = 2)
+    (terms - [term]).sort_by { |t| minkowski(term, t, dimension) }[0, num]
+  end
+
+  def minkowski(term1, term2, dimension, norm = true)
+    [term1, term2].map { |term| vector(term, norm).vector }
+      .inject(:-).abs.to_f.pow(dimension).sum ** 1.fdiv(dimension)
+  end
+
+  alias_method :distance, :minkowski
+
+  def euclidean(term1, term2, norm = true)
+    minkowski(term1, term2, 2, norm)
+  end
+
+  def manhattan(term1, term2, norm = true)
+    minkowski(term1, term2, 1, norm)
+  end
+
+  alias_method :cityblock, :manhattan
+
+  def to_a(norm = true)
+    norm ? each_norm.to_a : each_vector.to_a
+  end
+
+  def to_s
+    cols = [terms.unshift(nil)]
+
+    @matrix.each_col.with_index { |col, index|
+      cols << [@idmap.key(index), *col] unless col.isnull? }
+
+    fmt = cols.map { |col|
+      "%#{col.map { |val| val.to_s.length }.max}s" }.join(' ') << $/
+
+    cols.first.each_index.map { |index|
+      fmt % cols.map { |col| col[index] } }.join
+  end
+
+  def inspect
+    '#<%s:0x%x @window_size=%p, @size=%p>' % [
+      self.class, object_id, window_size, size
+    ]
+  end
+
+  private
+
+  def vector_i(index, norm)
+    @matrix.vector(index, size, norm)
+  end
+
+end
+
+require_relative 'hal4r/matrix'
+require_relative 'hal4r/vector'
+require_relative 'hal4r/version'

data/lib/hal4r/matrix.rb

@@ -0,0 +1,82 @@
+#--
+###############################################################################
+#                                                                             #
+# hal4r -- Hyperspace analogue to language for Ruby                           #
+#                                                                             #
+# Copyright (C) 2015 Jens Wille                                               #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@gmail.com>                                       #
+#                                                                             #
+# hal4r is free software; you can redistribute it and/or modify it under the  #
+# terms of the GNU Affero General Public License as published by the Free     #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# hal4r is distributed in the hope that it will be useful, but WITHOUT ANY    #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for     #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU Affero General Public License    #
+# along with hal4r. If not, see <http://www.gnu.org/licenses/>.               #
+#                                                                             #
+###############################################################################
+#++
+
+require 'forwardable'
+require 'gsl'
+
+class Hal4R
+
+  class Matrix
+
+    include Enumerable
+
+    extend Forwardable
+
+    DEFAULT_STEP = 512
+
+    def_delegator :@matrix, :size1, :size
+
+    def initialize(step = nil)
+      @matrix = matrix(@step = step || DEFAULT_STEP)
+    end
+
+    attr_accessor :step
+
+    def get(index)
+      expand unless index < size
+      @matrix.row(index)
+    end
+
+    def vector(index, size = size(), norm = false)
+      vector = @matrix.subrow(index, 0, size)
+        .concat(@matrix.subcolumn(index, 0, size))
+
+      Vector.new(norm ? vector.to_f.normalize : vector)
+    end
+
+    def each_col(&block)
+      block ? @matrix.each_col(&block) : enum_for(:each_col)
+    end
+
+    def inspect
+      '#<%s:0x%x @step=%p, @size=%p>' % [
+        self.class, object_id, step, size
+      ]
+    end
+
+    private
+
+    def expand(new_size = size + step)
+      @matrix = matrix(new_size).set(range = 0 .. size - 1, range, @matrix)
+    end
+
+    def matrix(size)
+      GSL::Matrix::Int.zeros(size)
+    end
+
+  end
+
+end

data/lib/hal4r/vector.rb

@@ -0,0 +1,51 @@
+#--
+###############################################################################
+#                                                                             #
+# hal4r -- Hyperspace analogue to language for Ruby                           #
+#                                                                             #
+# Copyright (C) 2015 Jens Wille                                               #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@gmail.com>                                       #
+#                                                                             #
+# hal4r is free software; you can redistribute it and/or modify it under the  #
+# terms of the GNU Affero General Public License as published by the Free     #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# hal4r is distributed in the hope that it will be useful, but WITHOUT ANY    #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for     #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU Affero General Public License    #
+# along with hal4r. If not, see <http://www.gnu.org/licenses/>.               #
+#                                                                             #
+###############################################################################
+#++
+
+class Hal4R
+
+  class Vector
+
+    include Enumerable
+
+    def initialize(vector)
+      @vector = vector
+    end
+
+    attr_reader :vector
+
+    def each(&block)
+      block ? vector.each(&block) : enum_for(:each)
+    end
+
+    def inspect
+      '#<%s:0x%x @vector=%p>' % [
+        self.class, object_id, vector
+      ]
+    end
+
+  end
+
+end

data/lib/hal4r/version.rb

@@ -0,0 +1,27 @@
+class Hal4R
+
+  module Version
+
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+
+    class << self
+
+      # Returns array representation.
+      def to_a
+        [MAJOR, MINOR, TINY]
+      end
+
+      # Short-cut for version string.
+      def to_s
+        to_a.join('.')
+      end
+
+    end
+
+  end
+
+  VERSION = Version.to_s
+
+end

data/spec/hal4r/matrix_spec.rb

@@ -0,0 +1,27 @@
+describe Hal4R::Matrix do
+
+  step = 5
+
+  subject { described_class.new(step) }
+
+  example do
+    expect(subject.get(0)).to eq(0)
+    expect(subject.vector(0)).to be_an_instance_of(Hal4R::Vector)
+    expect{subject.vector(step)}.to raise_error(GSL::ERROR::EINVAL, /row index is out of range/)
+  end
+
+  example do
+    expect(subject.get(step)).to eq(0)
+    expect(subject.vector(0)).to be_an_instance_of(Hal4R::Vector)
+    expect(subject.vector(step)).to be_an_instance_of(Hal4R::Vector)
+  end
+
+  example do
+    expect(subject.each_col).to be_an_instance_of(Enumerator)
+  end
+
+  example do
+    expect{|b|subject.each_col(&b)}.to yield_successive_args(*[GSL::Vector::Int::Col::View] * subject.size)
+  end
+
+end