rgraphum 0.0.1.alpha

data/lib/rgraphum/vertex.rb

@@ -0,0 +1,354 @@
+# -*- coding: utf-8 -*-
+
+def Rgraphum::Vertex(hash_or_vertex)
+  if hash_or_vertex.instance_of?(Rgraphum::Vertex)
+    hash_or_vertex
+  else
+    Rgraphum::Vertex.new(hash_or_vertex)
+  end
+end
+
+class Rgraphum::Vertex #< Hash
+  attr_accessor :graph
+
+  def initialize(fields={})
+    unless fields.empty?
+      unknown_fields = fields.keys - @@field_names
+      unless unknown_fields.empty?
+        raise ArgumentError, "No such field(s) in Vertex: #{unknown_fields.join(', ')}"
+      end
+      fields.each do |name, value|
+        self.send("#{name}=", value)
+      end
+    end
+    @edges = Rgraphum::Edges.new
+    @edges.vertex = self
+  end
+
+  # Gremlin: inE
+  #
+  # Gets the incoming edges of the vertex.
+  #
+  #     gremlin> v = g.v(4)
+  #     ==>v[4]
+  #     gremlin> v.inE.outV
+  #     ==>v[1]
+  #     gremlin> v.in
+  #     ==>v[1]
+  #     gremlin> v = g.v(3)
+  #     ==>v[3]
+  #     gremlin> v.in("created")
+  #     ==>v[1]
+  #     ==>v[4]
+  #     ==>v[6]
+  #     gremlin> v.inE("created").outV
+  #     ==>v[1]
+  #     ==>v[4]
+  #     ==>v[6]
+  #
+  def inE(*key)
+    find_edges(key, :in)
+  end
+  alias :in_e :inE
+
+  # Gremlin: outE
+  #
+  # Gets the outgoing edges to the vertex.
+  #
+  #     gremlin> v = g.v(1)
+  #     ==>v[1]
+  #     gremlin> v.outE.inV
+  #     ==>v[2]
+  #     ==>v[4]
+  #     ==>v[3]
+  #     gremlin> v.out
+  #     ==>v[2]
+  #     ==>v[4]
+  #     ==>v[3]
+  #     gremlin> v.outE('knows').inV
+  #     ==>v[2]
+  #     ==>v[4]
+  #     gremlin> v.out('knows')
+  #     ==>v[2]
+  #     ==>v[4]
+  #
+  def outE(*key)
+    find_edges(key, :out)
+  end
+  alias :out_e :outE
+
+  # Gremlin: bothE
+  #
+  # Get both incoming and outgoing edges of the vertex.
+  #
+  #     gremlin> v = g.v(4)
+  #     ==>v[4]
+  #     gremlin> v.bothE
+  #     ==>e[8][1-knows->4]
+  #     ==>e[10][4-created->5]
+  #     ==>e[11][4-created->3]
+  #     gremlin> v.bothE('knows')
+  #     ==>e[8][1-knows->4]
+  #     gremlin> v.bothE('knows', 'created')
+  #     ==>e[8][1-knows->4]
+  #     ==>e[10][4-created->5]
+  #     ==>e[11][4-created->3]
+  #
+  def bothE(*key)
+    find_edges(key, :both)
+  end
+  alias :both_e :bothE
+
+  # Gremlin: in
+  #
+  # Gets the adjacent vertices to the vertex.
+  #
+  #     gremlin> v = g.v(4)
+  #     ==>v[4]
+  #     gremlin> v.inE.outV
+  #     ==>v[1]
+  #     gremlin> v.in
+  #     ==>v[1]
+  #     gremlin> v = g.v(3)
+  #     ==>v[3]
+  #     gremlin> v.in("created")
+  #     ==>v[1]
+  #     ==>v[4]
+  #     ==>v[6]
+  #     gremlin> v.inE("created").outV
+  #     ==>v[1]
+  #     ==>v[4]
+  #     ==>v[6]
+  #
+  def in(*key)
+    find_vertices(key, :in)
+  end
+
+  # Gremlin: out
+  #
+  # Gets the out adjacent vertices to the vertex.
+  #
+  #     gremlin> v = g.v(1)
+  #     ==>v[1]
+  #     gremlin> v.outE.inV
+  #     ==>v[2]
+  #     ==>v[4]
+  #     ==>v[3]
+  #     gremlin> v.out
+  #     ==>v[2]
+  #     ==>v[4]
+  #     ==>v[3]
+  #     gremlin> v.outE('knows').inV
+  #     ==>v[2]
+  #     ==>v[4]
+  #     gremlin> v.out('knows')
+  #     ==>v[2]
+  #     ==>v[4]
+  #
+  def out(*key)
+    find_vertices(key, :out)
+  end
+
+  # Gremlin: both
+  #
+  # Get both adjacent vertices of the vertex, the in and the out.
+  #
+  #     gremlin> v = g.v(4)
+  #     ==>v[4]
+  #     gremlin> v.both
+  #     ==>v[1]
+  #     ==>v[5]
+  #     ==>v[3]
+  #     gremlin> v.both('knows')
+  #     ==>v[1]
+  #     gremlin> v.both('knows', 'created')
+  #     ==>v[1]
+  #     ==>v[5]
+  #     ==>v[3]
+  #
+  def both(*key)
+    find_vertices(key, :both)
+  end
+
+
+  # Non-Gremlin methods
+
+
+  def dup
+    super.tap { |vertex|
+      vertex.graph = nil
+      vertex.edges = @edges.dup
+      vertex.edges.vertex = vertex
+
+      vertex.edges.each do |edge|
+        if edge.source.equal?(self)
+          edge.source = vertex
+        end
+        if edge.target.equal?(self)
+          edge.target = vertex
+        end
+      end
+    }
+  end
+
+  def edges
+    @edges
+  end
+
+  def find_edges(labels=[], direction=:both)
+    case direction
+    when :in
+      results = @edges.where(target: self).all
+    when :out
+      results = @edges.where(source: self).all
+    else # :both
+      results = @edges
+    end
+
+    if labels.empty?
+      Rgraphum::Edges(results)
+    else
+      found_edges = results.find_all { |edge| labels.include?(edge.label) }
+      Rgraphum::Edges(found_edges)
+    end
+  end
+
+  def find_vertices(labels=[], direction=:both)
+    case direction
+    when :in
+      vertices = find_edges(labels, :in).map(&:source)
+    when :out
+      vertices = find_edges(labels, :out).map(&:target)
+    else # :both
+      vertices  = find_edges(labels, :in).map(&:source)
+      vertices += find_edges(labels, :out).map(&:target)
+    end
+    Rgraphum::Vertices(vertices)
+  end
+
+  def neighborhoods
+    raise NotImplementedError
+  end
+
+  def edges=(array)
+    return unless array.is_a?(Array)
+    @edges = Rgraphum::Edges(array)
+    @edges.vertex = self
+    @edges
+  end
+
+  def inter_edges
+    []
+  end
+
+  def clear_cache
+    @degree = nil
+    @degree_weight = nil
+  end
+
+  def degree
+    @degree ||= @edges.size
+  end
+
+  def degree_weight
+    @degree_weight ||= @edges.inject(0) { |sum, edge| sum + (edge.weight || 1.0) }
+  end
+
+  def sigma_tot
+    self.degree_weight
+  end
+
+  def sigma_in
+    0
+  end
+
+  def within_term(another)
+    return false unless self.start < another.start
+    return false unless another.start < self.end
+    true
+  end
+
+  # accessors
+
+  # attr_accessor :id
+  # attr_accessor :source, :target
+  # attr_accessor :start,  :end
+  # attr_accessor :label
+  # attr_accessor :count
+  # attr_accessor :attvalues
+  # attr_accessor :community
+  # attr_accessor :edges
+  # attr_accessor :words
+
+  def [](key)
+    send(key)
+  end
+
+  def []=(key, value)
+    send("#{key}=")
+  end
+
+  def ==(other)
+    if other.is_a?(Rgraphum::Vertex)
+      return false unless id == other.id
+    else
+      return id == other
+    end
+    return false unless edges == other.edges
+    true
+  end
+
+  def to_hash
+    hash = {}
+    @@field_names.each do |name|
+      value = instance_variable_get("@#{name}")
+      if value
+        if value.respond_to?(:to_hash)
+          hash[name] = value.to_hash
+        else
+          hash[name] = value
+        end
+      end
+    end
+    hash
+  end
+
+  def to_s
+    to_hash.to_s
+  end
+
+  # FIXME
+  def self.field(*field_names)
+    @@field_names ||= []
+    field_names = [field_names] unless field_names.is_a?(Array)
+    field_names.each do |field_name|
+      @@field_names << field_name.to_sym
+      class_eval <<-EOT, __FILE__, __LINE__ + 1
+        def #{field_name}
+          # self[:#{field_name}]
+          @#{field_name}
+        end
+        def #{field_name}=(rhs)
+          # self[:#{field_name}] = rhs if respond_to?(:[]=) # FIXME
+          @#{field_name} = rhs
+        end
+       EOT
+    end
+  end
+
+  def self.has_field?(field_name)
+    @@field_names.include?(field_name.to_sym)
+  end
+
+  field :id
+  field :source, :target
+  field :start,  :end
+  field :label
+  field :weight
+  field :count
+  field :attvalues
+  # field :community
+  field :community_id
+  # field :edges
+  field :words
+end

data/lib/rgraphum/vertices.rb

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+
+def Rgraphum::Vertices(array)
+  if array.instance_of?(Rgraphum::Vertices)
+    array
+  else
+    Rgraphum::Vertices.new(array)
+  end
+end
+
+class Rgraphum::Vertices < Rgraphum::RgraphumArray
+  include Rgraphum::RgraphumArrayDividers
+
+  # Non-Gremlin methods
+
+  def initialize(vertex_hashes=[])
+    super()
+    @id_vertex_map = {}
+    vertex_hashes.each do |vertex_hash|
+      self << vertex_hash
+    end
+  end
+
+  def find_by_id(vertex_id)
+    if vertex_id.is_a?(Rgraphum::Vertex)
+      id = vertex_id.id
+    else
+      id = vertex_id
+    end
+    @id_vertex_map[id]
+  end
+
+  # FIXME use initialize_copy instead
+  def dup
+    edges = map{ |vertex| vertex.edges }.flatten.uniq
+    vertices = super
+    vertices.each {|vertex| vertex.edges = Rgraphum::Edges.new }
+
+    edges.each do |edge_source|
+      edge = edge_source.dup
+      edge.source = vertices.find_by_id(edge.source.id)
+      edge.target = vertices.find_by_id(edge.target.id)
+
+      edge.source.edges << edge
+      edge.target.edges << edge
+    end
+
+    vertices
+  end
+
+  def build(vertex_hash)
+    vertex = Rgraphum::Vertex(vertex_hash)
+    vertex.graph = @graph
+    vertex.id = new_id(vertex.id)
+    original_push_1(vertex)
+    @id_vertex_map[vertex.id] = vertex
+    vertex
+  end
+
+  alias :original_push_1 :<<
+  def <<(vertex_hash)
+    build(vertex_hash)
+    self
+  end
+
+  alias :original_push_m :push
+  def push(*vertex_hashs)
+    vertex_hashs.each do |vertex_hash|
+      build(vertex_hash)
+    end
+    self
+  end
+
+  # Called from delete_if, reject! and reject
+  def delete(vertex_or_id)
+    id = vertex_or_id.id rescue vertex_or_id
+    target_vertex = find_by_id(id)
+    unless target_vertex.edges.empty?
+      target_vertex.edges.reverse_each do |edge|
+        target_vertex.edges.delete(edge)
+      end
+    end
+    @id_vertex_map.delete id
+    super(target_vertex)
+  end
+
+  def to_community
+    Rgraphum::Community.new(vertices: self)
+  end
+
+  def to_graph
+    to_community.to_graph
+  end
+
+  protected :original_push_1
+  protected :original_push_m
+end

data/lib/rgraphum.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+require 'time'
+
+module Rgraphum
+  def self.verbose?
+    !!ENV['VERBOSE']
+  end
+end
+
+require_relative 'rgraphum/parsers'
+require_relative 'rgraphum/marshal'
+require_relative 'rgraphum/simulator'
+
+require_relative 'rgraphum/tf_idf'
+require_relative 'rgraphum/cosine_similarity_matrix'
+
+require_relative 'rgraphum/rgraphum_random'
+
+require_relative 'rgraphum/rgraphum_array'
+require_relative 'rgraphum/rgraphum_array_dividers'
+require_relative 'rgraphum/vertex'
+require_relative 'rgraphum/vertices'
+require_relative 'rgraphum/edge'
+require_relative 'rgraphum/edges'
+require_relative 'rgraphum/community'
+require_relative 'rgraphum/communities'
+require_relative 'rgraphum/graph/math'
+require_relative 'rgraphum/graph/gremlin'
+require_relative 'rgraphum/importer'
+require_relative 'rgraphum/graph'
+
+require_relative 'rgraphum/path'
+require_relative 'rgraphum/cluster'
+
+require_relative 'rgraphum/analyzer'
+
+require_relative 'rgraphum/t'

data/performance/add-vertices-edges.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require_relative '../lib/rgraphum'
+
+graph = Rgraphum::Graph.new
+
+size = (ARGV.shift || 1000).to_i
+
+size.times do |n|
+  graph.vertices.build(label: "v#{n+1}")
+end
+
+size.times do |n1|
+  n2 = n1 + 1
+  n2 = 0 if n2 == size
+  v1 = graph.vertices[n1]
+  v2 = graph.vertices[n2]
+  graph.edges.build(source: v1, target: v2, weight: 1)
+end

data/performance/add-vertices.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require_relative '../lib/rgraphum'
+
+graph = Rgraphum::Graph.new
+
+size = (ARGV.shift || 1000).to_i
+
+size.times do |n|
+  graph.vertices.build(label: "v#{n+1}")
+end

data/performance/build-graph.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require_relative '../lib/rgraphum'
+
+graph = Rgraphum::Graph.new
+
+size = 30000
+
+size.times do |n|
+  graph.vertices.build(label: "v#{n+1}")
+end
+
+(0...size).step(10).each do |n|
+  v = graph.vertices[n]
+  ((n+1)...(n+10)).each do |i|
+    graph.edges.build(source: v, target: graph.vertices[i])
+  end
+end

data/performance/delete-graph.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require_relative '../lib/rgraphum'
+
+graph = Rgraphum::Graph.new
+
+size = 20000
+
+size.times do |n|
+  graph.vertices.build(label: "v#{n+1}")
+end
+
+(0...size).step(10).each do |n|
+  v = graph.vertices[n]
+  ((n+1)...(n+10)).each do |i|
+    graph.edges.build(source: v, target: graph.vertices[i])
+  end
+end
+
+until graph.edges.empty?
+  e = graph.edges.last
+  graph.edges.delete(e)
+end

data/performance/delete-vertices.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require_relative '../lib/rgraphum'
+
+graph = Rgraphum::Graph.new
+
+size = (ARGV.shift || 1000).to_i
+
+size.times do |n|
+  graph.vertices.build(label: "v#{n+1}")
+end
+
+size.times do |n1|
+  n2 = n1 + 1
+  n2 = 0 if n2 == size
+  v1 = graph.vertices[n1]
+  v2 = graph.vertices[n2]
+  graph.edges.build(source: v1, target: v2, weight: 1)
+end
+
+size.times do |n|
+  vertex = graph.vertices[rand(graph.vertices.size)]
+  graph.vertices.delete vertex
+end

data/performance/refer-graph.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require_relative '../lib/rgraphum'
+
+graph = Rgraphum::Graph.new
+
+size = 20000
+
+size.times do |n|
+  graph.vertices.build(label: "v#{n+1}")
+end
+
+(0...size).step(10).each do |n|
+  v = graph.vertices[n]
+  ((n+1)...(n+10)).each do |i|
+    graph.edges.build(source: v, target: graph.vertices[i])
+  end
+end
+
+size.times do |n|
+  graph.vertices.find_by_id(n)
+end

data/rgraphum.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+# require 'rgraphum/version'
+require 'rgraphum/version' # FIXME
+
+Gem::Specification.new do |spec|
+  spec.name          = "rgraphum"
+  spec.version       = Rgraphum::VERSION
+  spec.authors       = ["omi", "ice"]
+  spec.email         = ["rgraphum@rgraphum.com"]
+  spec.description   = %q{Rgraphum: Graphum ruby implementation}
+  spec.summary       = %q{Graphum is graph, vertex and edge manipulation library.}
+  spec.homepage      = "http://rgraphum.com"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+#  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.executables   = ['rgraphum_console','rgraphum_runner']
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.has_rdoc      = 'yard'
+
+  spec.add_dependency "builder"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "minitest"
+
+  spec.add_development_dependency 'yard'
+end

data/test/lib/rgraphum/analyzer/linear_regression_test.rb

@@ -0,0 +1,20 @@
+# coding: utf-8
+
+require 'test_helper'
+require 'rgraphum'
+
+class LinearRegressionTest < MiniTest::Test
+  def test_analyze
+    lr = Rgraphum::Analyzer::LinearRegression.new
+
+    # 1 degree
+    assert_equal ([2,3]), lr.analyze([1,2,3],[5,7,9])
+    assert_equal ([3,4]), lr.analyze([1,2,3],[7,10,13])
+    assert_equal ([4,5]), lr.analyze([1,2,3],[9,13,17])
+
+    # 2 degree
+#    assert_equal ([2,3,4]),lr.analyze([1,2,3],[9,18,31],2) 
+#    assert_equal ([3,4,5]),lr.analyze([1,2,3],[12,25,44],2) 
+#    assert_equal ([4,5,6]),lr.analyze([1,2,3],[15,32,57],2) 
+  end
+end