rgraphum 0.0.1.alpha

data/lib/rgraphum/parsers/miserables.rb

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+
+require 'json'
+
+module Rgraphum::Parsers
+  class MiserablesParser
+    class << self
+      def builder(graph)
+        stream = "var miserables = { vertices: ["
+
+        graph.vertices.each_with_index do |vertex, n|
+          vertex.class_eval { attr_accessor :no } # FIXME
+          vertex.no = n
+          # stream += "\n{vertexName: \"#{vertex.label}\", group: #{vertex[:community_id]}},"
+          stream += "\n" + { vertexName: vertex.label, group: vertex.community_id }.to_json + ","
+        end
+        stream.chop!
+        stream += "],\n"
+
+        stream += "links: ["
+        graph.edges.each do |edge|
+          stream += "\n{source: #{edge.source.no},"
+          stream += " target: #{edge.target.no},"
+          stream += " value: #{edge.weight}},"
+        end
+        stream.chop!
+        stream += "]\n"
+        stream += "};"
+
+        stream
+      end
+    end
+
+    # Options:
+    #
+    def initialize(options={})
+      default_options = {
+      }
+      @options = default_options.merge(options)
+      builder(@options[:graph]) if @options.key?(:graph)
+    end
+
+    def builder(graph)
+      @stream = self.class.builder(graph)
+    end
+
+    def to_s
+      unless @stream
+        raise ArgumentError, "Didn't build stream with builder(graph)"
+      end
+      @stream
+    end
+  end
+end

data/lib/rgraphum/parsers.rb

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+
+require_relative 'parsers/gephi'
+require_relative 'parsers/miserables'
+require_relative 'parsers/graphviz'
+require_relative 'parsers/flare'
+
+module Rgraphum::Parsers
+  # parsers
+  def to_gephi
+    self.real_aspect! if @aspect == "id"
+    gephi_xml = Rgraphum::Parsers::GephiParser.new(graph: self)
+  end
+
+  def to_miserables
+    self.real_aspect! if @aspect == "id"
+    stream = Rgraphum::Parsers::MiserablesParser.new(graph: self)
+  end
+
+  def to_graphviz( options={} )
+    self.real_aspect! if @aspect == "id"
+    default_options = { graph:self, layout: "dot" }
+    options = default_options.merge(options)
+    dot = Rgraphum::Parsers::GraphvizParser.new( options )
+  end
+
+  def to_flare
+    self.real_aspect! if @aspect == "id"
+    stream = Rgraphum::Parsers::MiserablesParser.new(graph: self)
+  end
+
+end

data/lib/rgraphum/path.rb

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+
+class Rgraphum::Path
+  attr_reader :end_vertex
+  attr_reader :vertices
+
+  # vertices:      Array of Rgraphum::Vertex
+  #
+  def initialize(end_vertex=nil, vertices=[])
+    @end_vertex = end_vertex
+    @vertices   = vertices
+  end
+
+  def include?(vertex)
+    vertices.include?(vertex)
+  end
+
+  def edges
+    # FIXME
+    last_vertex = vertices.first
+    graph = last_vertex.graph
+    new_edges = []
+    vertices.each do |vertex|
+      if last_vertex != vertex
+        edge   = graph.edges.where(source: last_vertex, target: vertex).first
+        edge ||= graph.edges.where(source: vertex, target: last_vertex).first
+        new_edges << edge
+      end
+      last_vertex = vertex
+    end
+    new_edges
+  end
+
+  def total_weight
+    edges.inject(0) { |sum, edge| sum + edge.weight }
+  end
+end

data/lib/rgraphum/query.rb

@@ -0,0 +1,130 @@
+# -*- coding: utf-8 -*-
+
+class Rgraphum::Query
+  include Enumerable
+
+  def initialize(array, *conditions)
+    @array = array
+    @conditions = []
+    @id_conditions = nil
+    where(*conditions)
+  end
+
+  def each(&block)
+    if block_given?
+      all.each do |item|
+        yield item
+      end
+    else
+      to_enum
+    end
+  end
+
+  def empty?
+    all.empty?
+  end
+
+  # where(id: 3).first
+  # where(label: "abc").all
+  # where(id: 1, label: "abc").all
+  # where(:label, :eq, "abc").all
+  # where(:label, :ne, "abc").all
+  def where(*conditions)
+    if conditions.size == 1 && conditions[0].is_a?(Hash)
+      conditions = conditions[0]
+    end
+    return self if conditions.empty?
+
+    case conditions
+    when Hash
+      conditions.each do |fieldname, rvalue|
+        condition = [fieldname, :eq, rvalue]
+        @conditions << condition
+        if fieldname == :id
+          @id_conditions ||= []
+          @id_conditions << condition
+        end
+      end
+    when Array
+      fieldname, operator, rvalue = conditions
+      condition = [fieldname, operator, rvalue]
+      @conditions << condition
+      if fieldname == :id && (operator == :eq || operator == :==)
+        @id_conditions ||= []
+        @id_conditions << condition
+      end
+    else
+      raise NotImplementedError
+    end
+
+    self
+  end
+
+  def all
+    if @id_conditions && @array.respond_to?(:find_by_id)
+      item = @array.find_by_id(@id_conditions.first[2])
+      if try_conditions(item)
+        [item]
+      else
+        []
+      end
+    else
+      @array.class.new( @array.select { |item| try_conditions(item) } )
+    end
+  end
+  alias :to_a :all
+
+  def first
+    if @id_conditions && @array.respond_to?(:find_by_id)
+      item = @array.find_by_id(@id_conditions.first[2])
+      return item if item && try_conditions(item)
+    else
+      @array.each do |item|
+        return item if try_conditions(item)
+      end
+    end
+    nil
+  end
+
+  def last
+    if @id_conditions && @array.respond_to?(:find_by_id)
+      item = @array.find_by_id(@id_conditions.first[2])
+      return item if item && try_conditions(item)
+    else
+      @array.reverse_each do |item|
+        return item if try_conditions(item)
+      end
+    end
+    nil
+  end
+
+  def method_missing(method_name, *args)
+    if @array.first.respond_to?(method_name)
+      all.map { |item| item.send(method_name) }
+    else
+      super
+    end
+  end
+
+  private
+
+  def try_conditions(item)
+    @conditions.each do |(fieldname, operator, rvalue)|
+      lvalue = item.send(fieldname)
+      case operator
+      when :eq,  :==; return false unless lvalue == rvalue
+      when :ne,  :!=; return false unless lvalue != rvalue
+      when :gt,  :>;  return false unless lvalue >  rvalue
+      when :gte, :>=; return false unless lvalue >= rvalue
+      when :lt,  :<;  return false unless lvalue <  rvalue
+      when :lte, :<=; return false unless lvalue <= rvalue
+      when :match,     :=~; return false unless lvalue =~ rvalue
+      when :not_match, :!~; return false unless lvalue !~ rvalue
+      else
+        raise ArgumentError, "Unknown operator #{operator}"
+      end
+    end
+    true
+  end
+
+end

data/lib/rgraphum/rgraphum_array.rb

@@ -0,0 +1,159 @@
+# -*- coding: utf-8 -*-
+
+require_relative 'query'
+
+class Rgraphum::RgraphumArray < Array
+  attr_accessor :graph
+
+#  def ids
+#    map { |obj| obj.id }
+#  end
+
+  # FIXME use initialize_copy instead
+  def dup
+    array = self.class.new
+    each do |item|
+      array << item.dup
+    end
+    array
+  end
+
+  def self.reset_id
+    remove_instance_variable :@new_id
+  end
+
+  # FIXME maybe better id to start from 1
+  # def self.new_id
+  #   @new_id ||= -1
+  #   @new_id += 1
+  # end
+
+  def new_id(id=nil)
+    # self.class.new_id
+    @new_id ||= -1
+    if id
+      @new_id = id if @new_id < id
+      id
+    else
+      @new_id += 1
+    end
+  end
+
+  def substitute(array, &block)
+    return unless array.is_a?(Array)
+    new_array = self.class.new
+    new_array.graph = @graph
+    array.each do |item|
+      if block_given?
+        new_array << (yield item)
+      else
+        new_array << item
+      end
+    end
+    new_array
+  end
+
+  alias :original_delete_if :delete_if
+  alias :original_reject!   :reject!
+  def delete_if
+    if block_given?
+      i = 0
+      size = self.size
+      while i < size
+        item = self[i]
+        if yield(item)
+          delete(item)
+          size -= 1
+        else
+          i += 1
+        end
+      end
+      self
+    else
+      to_enum
+    end
+  end
+  alias :reject! :delete_if
+
+  alias :original_reject :reject
+  def reject(&block)
+    dup.reject! &block
+  end
+
+  def where(*conditions)
+    Rgraphum::Query.new(self, *conditions)
+  end
+
+  # gremlin methods
+
+  # has
+  # Allows an element if it has a particular property. Utilizes several options for comparisons through T:
+  #   T.gt - greater than
+  #   T.gte - greater than or equal to
+  #   T.eq - equal to
+  #   T.neq - not equal to
+  #   T.lte - less than or equal to
+  #   T.lt - less than
+  # It is worth noting that the syntax of has is similar to g.V("name", "marko"), which has the difference of being a key index lookup and as such will perform faster. In contrast, this line, g.V.has("name", "marko"), will iterate over all vertices checking the name property of each vertex for a match and will be significantly slower than the key index approach.
+  #   gremlin> g.V.has("name", "marko").name
+  #   ==>marko
+  #   gremlin> g.v(1).outE.has("weight", T.gte, 0.5f).weight
+  #   ==>0.5
+  #   ==>1.0
+  #   gremlin> g.V.has("age", null).name
+  #   ==>lop
+  #   ==>ripple
+  def has(*conditions)
+    if conditions.size == 1
+      self.class.new( where( conditions[0], :!=, nil ) )
+    elsif conditions.size == 2
+      self.class.new( where( { conditions[0] => conditions[1] } ) )
+    elsif conditions.size == 3
+      self.class.new( where( *conditions ) )
+    end
+  end
+
+  # hasNot
+  # Allows an element if it does not have a particular property. Utilizes several options for comparisons on through T:
+  #   T.gt - greater than
+  #   T.gte - greater than or equal to
+  #   T.eq - equal to
+  #   T.neq - not equal to
+  #   T.lte - less than or equal to
+  #   T.lt - less than
+  #   gremlin> g.v(1).outE.hasNot("weight", T.eq, 0.5f).weight
+  #   ==>1.0
+  #   ==>0.4
+  #   gremlin> g.V.hasNot("age", null).name
+  #   ==>vadas
+  #   ==>marko
+  #   ==>peter
+  #   ==>josh
+  def hasNot(*conditions)
+    nor_hash = {
+      :== => :!=,
+      :!= => :==,
+      :<  => :>=,
+      :<= => :> ,
+      :>= => :<,
+      :>  => :<=,
+    }
+
+    if conditions.size == 1
+      self.class.new( where( conditions[0], :==, nil ) )
+    elsif conditions.size == 2
+      where( conditions[0], :!=, conditions[1] )
+    elsif conditions.size == 3
+      where( conditions[0], nor_hash[conditions[1]], conditions[2] )
+    end
+  end
+
+  def method_missing(name, *args)
+    if first.class.has_field?(name)
+      map{|item| item.send(name)}
+    else
+      super(name,*args)
+    end
+  end
+
+end

data/lib/rgraphum/rgraphum_array_dividers.rb

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+
+module Rgraphum::RgraphumArrayDividers
+  def divide_by_time(interval=20)
+    # interval is min
+
+    base_sec = interval * 60
+
+    each do |item|
+      if item.start
+        item.start = time_rounddown(item.start, base_sec)
+
+        if item.end
+          item.end = time_roundup(item.end,   base_sec)
+        else
+          item.end = time_roundup(item.start, base_sec)
+        end
+
+        if item.end > (item.start + base_sec)
+          (item.start.to_i + base_sec).step(item.end.to_i, base_sec) do |t|
+            new_item = item.dup
+            new_item.id = nil
+            new_item.start = Time.at(t)
+            new_item.end   = Time.at(t + base_sec - 1)
+
+            self << new_item
+          end
+          item.end = Time.at(item.start.to_i + base_sec - 1)
+        end
+      end
+    end
+  end
+
+  private
+
+  def time_rounddown(time, sec)
+    Time.at((time.to_i / sec) * sec)
+  end
+
+  def time_roundup(time, sec)
+    Time.at((time.to_i / sec) * sec + sec - 1)
+  end
+end

data/lib/rgraphum/rgraphum_random.rb

@@ -0,0 +1,5 @@
+module Rgraphum::RgraphumRandom
+  def power_low_rand(max,min,exponent)
+    ( (max**exponent-min**exponent)*rand() + min**exponent )**( 1.0/exponent )
+  end
+end 

data/lib/rgraphum/simulator/ba_model.rb

@@ -0,0 +1,140 @@
+# -*- coding: utf-8 -*-
+
+# About BA Model
+#   The BA Model is a mathematical model of the network with "growth" and "preferential attachment".
+#   Growth means that the network is added to vertices with a fixed number of edges one at a time.
+#   Preferential attachment shows that the more connected a vertex is, the more likely to receive new edge.
+#   An importance of the model is to generate scale-free networks.
+#   The consruction of the model is as follows;
+#     1st: Select vertices with the probability of each degree / graph's total degree,
+#     2nd: Add every selected vertices to new edge.
+#     3rd: Repeat the 1st step and the 2nd step until the number of vertices attain the target one.
+class Rgraphum::Simulator::BAModel
+  def initialize(options={})
+    if options[:graph]
+      @graph = options[:graph].dup
+    else
+      @graph = Rgraphum::Graph.new
+    end
+  end
+
+  # Simurate BAmodel
+  # @param [Hash] options BAmodel's options
+  # @option options [Graph]   :graph (graph) start(base) origin graph.
+  #   default is a graph which used on newly constructing BAModel
+  # @option options [Integer] :round (10,000) simurate rounds, this means added vertex size
+  # @option options [Integer] :edge_size (1)  edge size on once added a vertex
+  # @option options [Integer] :interval  (1)  plus time(min) on new vertex and its edges if vertex or edge has 'cteated_at' value.
+  # @option options [Float]   :new_vertex_rate (1.0) Probability of adding new vertex.
+  #   If you need to add no new vertex but add edge, use this rate(0.0 - 1.0).
+  #   default is 1.0. it means always add new vertex
+  # @return [Graph]  a graph after simurate, not same origin graph.
+  #
+  def simulate(options={})
+    default_options = {
+      graph: @graph,
+      round: 10_000,
+      edge_size: 1,
+      interval:  1,
+      new_vertex_rate: 1.0,
+      random_seed: 10,
+    }
+    options = default_options.merge(options)
+
+    srand options[:random_seed]
+    graph = options[:graph]
+
+    base_vertices_size = graph.vertices.size
+
+    while graph.vertices.size - base_vertices_size < options[:round]
+      t_v = target_vertex(graph, options[:new_vertex_rate])
+      options[:edge_size].times do
+        edge = graph.edges.build( { source: source_vertex(graph), target: t_v } )
+      end
+    end
+    graph
+  end
+
+  # selecting source vertex method
+  #   Propability of BAModel's vertex selection divide
+  #   into probability of edges selection and probalility of source or target selection on edge.
+  #   And select source vertex
+  def source_vertex(graph=@graph)
+    return graph.vertices.build({label: new_dummy_label}) if graph.edges.size == 0
+
+    edge_index = rand( graph.edges.size )
+    if rand(2) == 0
+      source_vertex = graph.edges[edge_index][:source]
+    else
+      source_vertex = graph.edges[edge_index][:target]
+    end
+  end
+
+  # selecting target vertex method
+  #   with new_vertex_rate, select new vertex or existing vertex.
+  #   if selectiong new vertex, make new vertex and add it on graph
+  # @param [Graph] graph (@graph)
+  # @param [Float] new_vertex_rate (1.0)
+  # @return [Vertex]
+  def target_vertex(graph=@graph, new_vertex_rate=1.0)
+    vertices = graph.vertices
+    if new_vertex_rate < rand and vertices.size > 0
+      target_vertex = vertices[rand(vertices.size)]
+    else
+      graph.vertices.build(label: new_dummy_label)
+    end
+  end
+
+  # new dummy label method
+  def new_dummy_label
+    @dummy_label_index ||= 0
+    @dummy_labels ||= ("a".."aaaaaa").to_a
+    dummy_label = @dummy_labels[@dummy_label_index]
+    @dummy_label_index += 1
+    dummy_label
+  end
+
+  ######################################################################
+  # @private
+  def vertices_per_min(graph=@graph)
+    return nil if graph.vertices.empty?
+    first_vertex = graph.vertices.min_by { |vertex| vertex.start }
+    last_vertex  = graph.vertices.max_by { |vertex| vertex.start }
+    graph.vertices.size / ((last_vertex.start - first_vertex.start) / 60.0)
+  end
+
+  def edges_per_min(graph=@graph)
+    return nil if graph.edges.empty?
+    first_vertex = graph.edges.min_by { |edge| edge.start }
+    last_vertex  = graph.edges.max_by { |edge| edge.start }
+    graph.edges.size / ((last_vertex.start - first_vertex.start) / 60.0)
+  end
+
+  def edges_size_array_per_interval(graph=@graph, interval=1)
+    sorted_edges = graph.edges.sort{ |a, b| a.start <=> b.start}
+    step = interval * 60
+
+    start_time = sorted_edges[0].start.to_i / step * 60
+    end_time   = sorted_edges[-1].start.to_i / step * 60 + 1
+
+    time_array = []
+    time = start_time + step
+    size = 0
+    starts = sorted_edges.map { |edge| edge.start.to_i }
+
+    time, time_array = next_time(starts, time, step, time_array, size)
+
+    time_array
+  end
+
+  def next_time(sources, time, step, time_array, size)
+    return [time, time_array + [size]] if sources.empty?
+    if sources[0] >= time
+      time_array << size
+      time, time_array = next_time(sources, time+step, step, time_array, 0)
+    else
+      sources.shift
+      time, time_array = next_time(sources, time, step, time_array, size + 1)
+    end
+  end
+end