rgraphum 0.0.1.alpha

data/lib/rgraphum/edge.rb

@@ -0,0 +1,194 @@
+# -*- coding: utf-8 -*-
+
+def Rgraphum::Edge(hash_or_edge)
+  if hash_or_edge.instance_of?(Rgraphum::Edge)
+    hash_or_edge
+  else
+    Rgraphum::Edge.new(hash_or_edge)
+  end
+end
+
+class Rgraphum::Edge #< Hash
+  attr_accessor :graph
+  # attr_accessor :vertex
+
+  def initialize(fields={})
+    unless fields[:source] && fields[:target]
+      raise ArgumentError, "Edge.new: :source and :target options are required"
+    end
+
+    self.source = fields.delete(:source)
+    self.target = fields.delete(:target)
+
+    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
+
+    self.weight ||= 1
+  end
+
+  # Gremlin: outV
+  #
+  # Get both outgoing tail vertex of the edge.
+  #
+  #     gremlin> e = g.e(12)
+  #     ==>e[12][6-created->3]
+  #     gremlin> e.outV
+  #     ==>v[6]
+  #     gremlin> e.inV
+  #     ==>v[3]
+  #     gremlin> e.bothV
+  #     ==>v[6]
+  #     ==>v[3]
+  #
+  def outV
+    self.source
+  end
+  alias :out_v :outV
+
+  # Gremlin: inV
+  #
+  # Get both incoming head vertex of the edge.
+  #
+  #     gremlin> e = g.e(12)
+  #     ==>e[12][6-created->3]
+  #     gremlin> e.outV
+  #     ==>v[6]
+  #     gremlin> e.inV
+  #     ==>v[3]
+  #     gremlin> e.bothV
+  #     ==>v[6]
+  #     ==>v[3]
+  #
+  def inV
+    self.target
+  end
+  alias :in_v :inV
+
+  # Gremlin: bothV
+  #
+  # Get both incoming and outgoing vertices of the edge.
+  #
+  #     gremlin> e = g.e(12)
+  #     ==>e[12][6-created->3]
+  #     gremlin> e.outV
+  #     ==>v[6]
+  #     gremlin> e.inV
+  #     ==>v[3]
+  #     gremlin> e.bothV
+  #     ==>v[6]
+  #     ==>v[3]
+  #
+  def bothV
+    [outV, inV]
+  end
+  alias :both_v :bothV
+
+
+  # Non-Gremlin methods
+
+
+  # def id
+  #   self[:id]
+  # end
+
+  def update_vertices(vertices)
+    self.source = find_vertex(:source, vertices)
+    self.target = find_vertex(:target, vertices)
+  end
+  
+  def find_vertex(syn, vertices)
+    vertex =  self[syn]
+    if vertex.instance_of?(Rgraphum::Vertex) and vertex.graph.equal?(@graph)
+      vertex
+    else
+      vertex = vertices.find_by_id(vertex)
+    end
+
+    unless vertex
+      p "edge has no #{syn}" if Rgraphum.verbose?
+    end
+    vertex
+  end
+
+  # accessors
+
+  # attr_accessor :id
+  # attr_accessor :source, :target
+  # attr_accessor :start,  :end
+  # attr_accessor :label
+  # attr_accessor :weight
+  # attr_accessor :attvalues
+
+  def [](key)
+    send(key)
+  end
+
+  def []=(key, value)
+    send("#{key}=")
+  end
+
+  def ==(other)
+    if other.is_a?(Rgraphum::Edge)
+      return false unless id == other.id
+    else
+      return id == other
+    end
+    return false unless source == other.source
+    return false unless target == other.target
+    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 :attvalues
+end

data/lib/rgraphum/edges.rb

@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+
+def Rgraphum::Edges(array)
+  if array.instance_of?(Rgraphum::Edges)
+    array
+  else
+    Rgraphum::Edges.new(array)
+  end
+end
+
+class Rgraphum::Edges < Rgraphum::RgraphumArray
+  include Rgraphum::RgraphumArrayDividers
+
+  attr_accessor :vertex
+
+  # Gremlin: outV
+  #
+  # Get both outgoing tail vertex of the edge.
+  #
+  #     gremlin> e = g.e(12)
+  #     ==>e[12][6-created->3]
+  #     gremlin> e.outV
+  #     ==>v[6]
+  #     gremlin> e.inV
+  #     ==>v[3]
+  #     gremlin> e.bothV
+  #     ==>v[6]
+  #     ==>v[3]
+  #
+  def outV
+    self.map{ |edge| edge.source }
+  end
+  alias :out_v :outV
+
+  # Gremlin: inV
+  #
+  # Get both incoming head vertex of the edge.
+  #
+  #     gremlin> e = g.e(12)
+  #     ==>e[12][6-created->3]
+  #     gremlin> e.outV
+  #     ==>v[6]
+  #     gremlin> e.inV
+  #     ==>v[3]
+  #     gremlin> e.bothV
+  #     ==>v[6]
+  #     ==>v[3]
+  #
+  def inV
+    self.map{ |edge| edge.target }
+  end
+  alias :in_v :inV
+
+
+  # Non-Gremlin methods
+
+
+  def initialize(edge_hashes=[])
+    super()
+    @id_edge_map = {}
+    edge_hashes.each do |edge_hash|
+      self << edge_hash
+    end
+  end
+
+  def find_by_id(edge_id)
+    if edge_id.is_a?(Rgraphum::Edge)
+      id = edge_id.id
+    else
+      id = edge_id
+    end
+    @id_edge_map[id]
+  end
+
+  def find_vertex(vertex)
+    vertices = @graph.vertices
+
+    if vertex.is_a?(Rgraphum::Vertex) and vertex.graph.equal?(@graph)
+      vertex
+    else
+      vertices.find_by_id(vertex)
+    end
+  end
+
+  def build(edge_or_hash, recursive=true)
+    if @vertex and @vertex.graph
+      if recursive
+        edge = @vertex.graph.edges.build(edge_or_hash, false)
+      else
+        edge = edge_or_hash
+        original_push_1 edge
+      end
+    else
+      edge = Rgraphum::Edge(edge_or_hash)
+      if @graph
+        source_vertex = find_vertex(edge.source)
+        target_vertex = find_vertex(edge.target)
+        raise ArgumentError, "Source vertex is required" unless source_vertex
+        raise ArgumentError, "Target vertex is required" unless target_vertex
+        edge.source = source_vertex
+        edge.target = target_vertex
+
+        edge.id = new_id(edge.id)
+        edge.graph = @graph
+        edge.source.edges.build(edge, false)
+        edge.target.edges.build(edge, false)
+      end
+      original_push_1 edge
+    end
+
+    @id_edge_map[edge.id] = edge
+
+    edge
+  end
+
+  alias :original_push_1 :<<
+  def <<(edge_or_hash)
+    build(edge_or_hash)
+    self
+  end
+
+  alias :original_push_m :push
+  def push(*edge_hashes)
+    edge_hashes.each do |edge_hash|
+      build(edge_hash)
+    end
+    self
+  end
+
+  # Called from delete_if, reject! and reject
+  def delete(edge_or_id, recursive=true)
+    id = edge_or_id.id rescue edge_or_id
+    target_edge = find_by_id(id)
+
+    return edge_or_id unless target_edge
+    deleted_edge = super(target_edge)
+
+    if @vertex and @vertex.graph
+      if recursive
+        @vertex.graph.edges.delete(target_edge, false)
+      end
+    else
+      if @graph
+        target_edge.source.edges.delete(target_edge, false)
+        target_edge.target.edges.delete(target_edge, false)
+      end
+    end
+    @id_edge_map.delete id
+
+    deleted_edge
+  end
+
+#  def weights
+#    self.map{ |edge| edge.weight }
+#  end
+
+  protected :original_push_1
+  protected :original_push_m
+
+  private
+end

data/lib/rgraphum/ext/cosine_similarity_matrix.rb

@@ -0,0 +1,79 @@
+class CosineSimilarityMatrix
+
+    inline do |builder|
+      builder.include "<math.h>"
+      builder.add_compile_flags "-fopenmp"
+      builder.c <<-EOF
+
+      VALUE c_similarity( VALUE ary ){
+        int i,j,k;
+
+        int m = RARRAY_LEN(ary);
+        int n = RARRAY_LEN(rb_ary_entry(ary,0));
+
+        float **val;
+        float *s;
+
+        float dot_ab   = 0.0;
+        float sq_sum_a = 0.0;
+        float sq_sum_b = 0.0;
+        VALUE sim_ary = rb_ary_new();
+        VALUE sim     = rb_ary_new();
+
+        // float val[m][n];
+        val = malloc(sizeof(float *) * m);
+        for (i=0;i<m;i++){
+          val[i] = malloc(sizeof(float) * n);
+        }
+
+        // float s[m][n];
+        s = malloc( sizeof(float) * m * m);
+
+        // init
+        for( i=0; i<m; i++){
+          for( j=0; j<n; j++){
+            val[i][j] = NUM2DBL( rb_ary_entry(rb_ary_entry(ary,i),j) );
+          }
+        }
+
+
+        for( i=0; i<m; i++){
+          for( j=0; j<m; j++){
+            if( i == j ){
+              s[i*m + j] = 1.0;
+            } else if( i > j ){
+              s[i*m + j] = s[j*m + i];
+            } else {
+              dot_ab   = 0.0;
+              sq_sum_a = 0.0;
+              sq_sum_b = 0.0;
+
+              for( k=0; k<n; k++){
+                dot_ab   += ( val[i][k] * val[j][k] );
+                sq_sum_a += ( val[i][k] * val[i][k] );
+                sq_sum_b += ( val[j][k] * val[j][k] );
+              }
+              s[i*m + j] = dot_ab / ( sqrt( sq_sum_a * sq_sum_b) );
+
+            }
+          }   
+        }
+
+        for( i=0; i<m; i++){
+          sim = rb_ary_new();
+          for( j=0; j<m; j++){
+            rb_ary_push( sim, DBL2NUM(s[i*m + j] ));
+          }   
+          rb_ary_push( sim_ary, sim );
+        }
+
+        free(val);
+        free(s);
+
+        return sim_ary;
+      }
+ 
+      EOF
+    end
+end
+

data/lib/rgraphum/ext/linear_regression.rb

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+
+#require 'numru/lapack'
+
+class Rgraphum::Analyzer::LinearRegression
+  def analyze(x_array, y_array, degree=1, round=5)
+
+    nrow = x_array.size
+    nx   = NArray.to_na(x_array)
+    nxm  = NMatrix.sfloat(nrow,degree + 1)
+
+    (degree + 1).times.each do |d|
+      nxm[(degree - d) * nrow] = nx ** d
+    end
+
+    ny = NArray.to_na([y_array])
+    s, rank, work, info, b = NumRu::Lapack.dgelsd(nxm, ny, 0)
+
+    b.to_a[0].map { |n| n.round(round) }
+
+  end
+end

data/lib/rgraphum/ext/tf_idf.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+require 'matrix'
+require 'inline'
+
+class TfIdf
+
+  inline do |builder|
+    builder.include "<math.h>"
+    builder.add_compile_flags "-fopenmp"
+    builder.c <<-EOF 
+
+    VALUE tf_idf( VALUE ary ){
+      int i,j,k;
+      int m = RARRAY_LEN(ary);
+      int n = RARRAY_LEN(rb_ary_entry(ary,0));
+
+      float words_amount;
+      float non_word;
+      float idfT;
+
+      VALUE tf_idf     = rb_ary_new();
+      VALUE tf_idf_ary = rb_ary_new();
+
+      /* tf-idf and output*/
+      for( i=0; i<m; i++){
+
+        /* tf base */
+        words_amount = 0.0;
+        for( j=0; j<n; j++){
+          words_amount = words_amount + FIX2INT( rb_ary_entry(rb_ary_entry(ary,i),j) );
+        }
+        
+        tf_idf = rb_ary_new();
+        for( j=0; j<n; j++){
+          non_word = 0.0;
+          for( k=0; k<m; k++){
+            if( FIX2INT( rb_ary_entry(rb_ary_entry(ary,k),j)) == 0 ){
+              non_word = non_word + 1;
+            } 
+          }
+          idfT = log( m / ( m - non_word ) );
+          rb_ary_push( tf_idf, DBL2NUM( ( FIX2INT(rb_ary_entry(rb_ary_entry(ary,i),j)) / words_amount ) * idfT ));
+        }   
+        rb_ary_push( tf_idf_ary, tf_idf );
+      }
+
+      return tf_idf_ary;         
+    }
+    EOF
+  end
+end

data/lib/rgraphum/graph/gremlin.rb

@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+class Rgraphum::Graph
+end
+
+module Rgraphum::Graph::Gremlin
+
+  # Gremlin: Graph.v
+  #
+  # Get a vertex or set of vertices by providing one or more vertex identifiers.
+  # The identifiers must be the identifiers assigned by the underlying graph implementation.
+  #
+  #     gremlin> g.v(1)
+  #     ==>v[1]
+  #     gremlin> g.v(1,2,3)
+  #     ==>v[1]
+  #     ==>v[2]
+  #     ==>v[3]
+  #     gremlin> ids = [1,2,3]
+  #     ==>1
+  #     ==>2
+  #     ==>3
+  #     gremlin> g.v(ids.toArray())
+  #     ==>v[1]
+  #     ==>v[2]
+  #     ==>v[3]
+  #  
+  # @param [Array] ids 
+  def v(*ids)
+    ids = ids.flatten
+
+    return @vertices.find_by_id(ids[0]) if ids.size == 1
+
+    new_vertices = Rgraphum::Vertices.new
+    ids.each do |id|
+      new_vertices << @vertices.find_by_id(id)
+    end
+
+    new_vertices
+  end
+
+  # Gremlin: Graph.e
+  #
+  # Get an edge or set of edges by providing one or more edge identifiers.
+  # The identifiers must be the identifiers assigned by the underlying graph implementation.
+  #
+  #     gremlin> g.e(10)
+  #     ==>e[10][4-created->5]
+  #     gremlin> g.e(10,11,12)
+  #     ==>e[10][4-created->5]
+  #     ==>e[11][4-created->3]
+  #     ==>e[12][6-created->3]
+  #     gremlin> ids = [10,11,12]
+  #     ==>10
+  #     ==>11
+  #     ==>12
+  #     gremlin> g.e(ids.toArray())
+  #     ==>e[10][4-created->5]
+  #     ==>e[11][4-created->3]
+  #     ==>e[12][6-created->3]
+  #
+  # @param [Array] ids 
+  def e(*ids)
+    ids = ids.flatten
+
+    return @edges.find_by_id(ids[0]) if ids.size == 1
+
+    new_edges = Rgraphum::Edges.new
+    ids.each do |id|
+      new_edges << @edges.find_by_id(id)
+    end
+
+    new_edges
+  end
+
+  # Gremlin: V
+  #
+  # The vertex iterator for the graph.
+  # Utilize this to iterate through all the vertices in the graph.
+  # Use with care on large graphs unless used in combination with a key index lookup.
+  #
+  #     gremlin> g.V
+  #     ==>v[3]
+  #     ==>v[2]
+  #     ==>v[1]
+  #     ==>v[6]
+  #     ==>v[5]
+  #     ==>v[4]
+  #     gremlin> g.V("name", "marko")
+  #     ==>v[1]
+  #     gremlin> g.V("name", "marko").name
+  #     ==>marko
+  # 
+  # @param [String] key
+  # @param [String] value
+  def V(key=nil,value=nil)
+    if key
+      @vertices.where( { key => value } ).all
+    else
+      @vertices
+    end
+  end
+
+
+  # Gremlin: E
+  #
+  # The edge iterator for the graph.
+  # Utilize this to iterate through all the edges in the graph.
+  # Use with care on large graphs.
+  #
+  #     gremlin> g.E
+  #     ==>e[10][4-created->5]
+  #     ==>e[7][1-knows->2]
+  #     ==>e[9][1-created->3]
+  #     ==>e[8][1-knows->4]
+  #     ==>e[11][4-created->3]
+  #     ==>e[12][6-created->3]
+  #     gremlin> g.E.weight
+  #     ==>1.0
+  #     ==>0.5
+  #     ==>0.4
+  #     ==>1.0
+  #     ==>0.4
+  #     ==>0.2
+  #
+  def E(key=nil,value=nil)
+    if key
+      @edges.find_all {|edge| vertex.send(key) == value }
+    else
+      @edges
+    end
+  end
+
+  # Gremlin: Graph.addVertex
+  #
+  # Adds a vertex to the graph.
+  # Note that most graph implementations ignore the identifier supplied to addVertex.
+  #
+  #     gremlin> g = new TinkerGraph()
+  #     ==>tinkergraph[vertices:0 edges:0]
+  #     gremlin> g.addVertex()
+  #     ==>v[0]
+  #     gremlin> g.addVertex(100)
+  #     ==>v[100]
+  #     gremlin> g.addVertex(null,[name:"stephen"])
+  #     ==>v[1]
+  #
+  def addVertex(id=nil, vertex=nil)
+    vertex ||= Rgraphum::Vertex.new(id: id)
+    vertex = Rgraphum::Vertex.new(vertex) unless vertex.is_a?(Rgraphum::Vertex) # FIXME
+    @vertices << vertex
+    @vertices[-1]
+  end
+  alias :add_vertex :addVertex
+
+  # Gremlin: Graph.addEdge
+  #
+  # Adds an edge to the graph.
+  # Note that most graph implementations ignore the identifier supplied to addEdge.
+  #
+  #     gremlin> g = new TinkerGraph()
+  #     ==>tinkergraph[vertices:0 edges:0]
+  #     gremlin> v1 = g.addVertex(100)
+  #     ==>v[100]
+  #     gremlin> v2 = g.addVertex(200)
+  #     ==>v[200]
+  #     gremlin> g.addEdge(v1,v2,'friend')
+  #     ==>e[0][100-friend->200]
+  #     gremlin> g.addEdge(1000,v1,v2,'buddy')
+  #     ==>e[1000][100-buddy->200]
+  #     gremlin> g.addEdge(null,v1,v2,'pal',[weight:0.75f])
+  #     ==>e[1][100-pal->200]
+  #
+  def addEdge( *params )
+    if params.size == 3
+      source = params[0]; target = params[1]; label = params[2]
+      @edges << Rgraphum::Edge.new(source: source, target: target, label: label)
+      @edges[-1]
+    elsif params.size == 4
+      id = params[0]; source = params[1]; target = params[2]; label = params[3]
+      @edges.build(id: id, source: source, target: target, label: label)
+    elsif params.size == 5
+      edge_hash = {}
+      edge_hash[:id] = params[0];
+      edge_hash[:source] = params[1];
+      edge_hash[:target] = params[2];
+      edge_hash[:label]  = params[3];
+      edge_hash.merge!(params[4])
+      @edges.build(edge_hash)
+    end
+  end
+  alias :add_edge :addEdge
+
+end