rgraph 0.0.9 → 0.0.10

data/lib/rgraph/graph.rb

@@ -6,24 +6,32 @@ require_relative '../../lib/rgraph/node'
 class Graph
   attr_accessor :nodes, :links, :infinity
 
+  def self.new_from_string(string)
+    csv = CSV.new(string, headers: true)
+    new(csv)
+  end
+
   def initialize(csv)
     @nodes = []
     @links = []
     @distance = nil
     @infinity = 100_000
-    raise Exception.new("the file must be a .csv") unless File.extname(csv) == ".csv"
 
-    CSV.foreach(csv, headers: true) do |row|
+    csv = CSV.new(File.open(csv), headers: true) if csv.is_a?(String)
+
+    csv.each do |row|
       #last because CSV#delete returns [column,value]
       source_id = row.delete('source').last
       target_id = row.delete('target').last
+      type = row.delete('type').last || 'undirected'
+      weight = row.delete('weight').last || 1
 
       source = get_node_by_id(source_id) || Node.new(id: source_id)
       target = get_node_by_id(target_id) || Node.new(id: target_id)
 
       maybe_add_to_nodes(source, target)
 
-      @links << Link.new(source: source, target: target, weight: row['weight'], year: row['year'])
+      @links << Link.new(source: source, target: target, weight: weight, type: type)
     end
   end
 
@@ -84,6 +92,13 @@ class Graph
     @distance
   end
 
+  def mdistance
+    distances unless @distance
+
+    fdistance = @distance.flatten.select{|d| d != @infinity}
+    fdistance.inject(:+) / fdistance.count.to_f
+  end
+
   def shortest_paths
     tmp = []
 
@@ -127,7 +142,7 @@ class Graph
 
   def betweenness(args = {})
     cumulative = args[:cumulative] || false
-    
+
     #If we ask cumulative, normalized must be true
     normalized = args[:normalized] || cumulative || false
 
@@ -153,8 +168,50 @@ class Graph
     (distances.flatten - [@infinity]).max
   end
 
+  def single_clustering(node)
+    possible = possible_connections(node)
+    return 0 if possible == 0
+
+    existent = node.neighbours.combination(2).select{ |t| t[0].neighbours.include?(t[1]) }.count
+    existent / possible.to_f
+  end
+
+  def clustering
+    nodes.map{ |node| single_clustering(node) }.inject(:+) / nodes.size.to_f
+  end
+
+  def page_rank(d = 0.85, e = 0.01)
+    n = @nodes.count
+
+    #Initial values
+    @page_rank = Array.new(n, 1 / n.to_f)
+
+    while true
+      return @page_rank if @page_rank.inject(:+) - step_page_rank(d, e).inject(:+) < e
+    end
+  end
+
   private
 
+  def step_page_rank(d = 0.85, e = 0.01)
+    n = @nodes.count
+    tmp = Array.new(n, 0)
+
+    @nodes.each_with_index do |node,i|
+      #How much 'node' will give to its neighbours
+      to_neighbours = @page_rank[i] / node.neighbours.count
+
+      #Give 'to_neighbours' to each neighbour
+      node.neighbours.each do |ne|
+        j = @nodes.index(ne)
+        tmp[j] += to_neighbours
+      end
+    end
+
+    #Calculates the final value
+    @page_rank = tmp.map{|t| ((1 - d) / n) + t * d}
+  end
+
   def get_node_by_id(node_id)
     @nodes.select{|n| n.id == node_id}.first
   end
@@ -164,4 +221,9 @@ class Graph
       @nodes << node unless get_node_by_id(node.id)
     end
   end
+
+  def possible_connections(node)
+    total = node.neighbours.count
+    total * (total - 1) / 2
+  end
 end

data/lib/rgraph/link.rb

@@ -1,10 +1,11 @@
 class Link
-  attr_accessor :source, :target
+  attr_accessor :source, :target, :type
 
   def initialize(arg)
     @args = arg
     @source = @args.delete(:source)
     @target = @args.delete(:target)
+    @type = @args.delete(:type) || 'undirected'
 
     raise Exception.new("source cant be nil") unless @source
     raise Exception.new("target cant be nil") unless @target
@@ -14,7 +15,7 @@ class Link
     @args[:weight] ||= 1
 
     @source.neighbours << @target
-    @target.neighbours << @source
+    @target.neighbours << @source unless @type == 'directed'
   end
 
   def method_missing(name, *args)

data/lib/rgraph/version.rb

@@ -1,3 +1,3 @@
 module Rgraph
-  VERSION = '0.0.9'
+  VERSION = '0.0.10'
 end

data/spec/rgraph/graph_spec.rb

@@ -39,8 +39,17 @@ describe Graph do
       expect(Graph.new('spec/fixtures/2005.csv').nodes.size).to eq(445)
     end
 
-    it "creates a Graph with a not csv file" do
-      expect { Graph.new('spec/fixtures/2005') }.to raise_exception("the file must be a .csv")
+    it "creates a graph with string as input" do
+      graph = Graph.new_from_string("source,target\n1,2")
+      expect(graph.nodes.count).to eq(2)
+      expect(graph.links.count).to eq(1)
+    end
+
+    it "understands directed graph" do
+      graph = Graph.new_from_string("source,target,type\n1,2,directed")
+      expect(graph.nodes.first.neighbours.count).to eq(1)
+      expect(graph.nodes.last.neighbours.count).to eq(0)
+      expect(graph.links.count).to eq(1)
     end
   end
 
@@ -76,7 +85,7 @@ describe Graph do
          [k,k,k,1,k,0]])
     end
 
-    it "checks distances" do
+    it "calculates distances" do
       expect(subject.distances).to eq(
         [[0,1,2,2,1,3],
          [1,0,1,2,1,3],
@@ -86,6 +95,17 @@ describe Graph do
          [3,3,2,1,2,0]])
     end
 
+    it "calculates the mean distance" do
+        mdistance = subject.distances.flatten
+        mdistance = mdistance.inject(:+) / mdistance.count.to_f
+        expect(subject.mdistance).to eq(mdistance)
+    end
+
+    it "calculates the mean distance ignoring 'infinity'" do
+      graph = Graph.new('spec/fixtures/two_links_with_hole.csv')
+      expect(graph.mdistance).to eq(10.0/13.0)
+    end
+
     it "understands holes on the graph" do
       graph = Graph.new('spec/fixtures/two_links_with_hole.csv')
       k = graph.infinity
@@ -149,5 +169,47 @@ describe Graph do
     it "calculates cumulative betweenness" do
       expect(subject.betweenness(cumulative: true)).to eq([[6, 0.0], [4, 0.5], [1, 1.0]])
     end
+    it "calculates clustering of a single node" do
+      nodes = subject.nodes.sort{|a,b| a.id <=> b.id}
+
+      expect(subject.single_clustering(nodes[0])).to eq(1.0/1.0)
+      expect(subject.single_clustering(nodes[1])).to eq(1.0/3.0)
+      expect(subject.single_clustering(nodes[2])).to eq(0.0/1.0)
+      expect(subject.single_clustering(nodes[3])).to eq(0.0/3.0)
+      expect(subject.single_clustering(nodes[4])).to eq(1.0/3.0)
+      expect(subject.single_clustering(nodes[5])).to eq(0.0/1.0)
+    end
+    it "calculates clustering of all nodes" do
+      expect(subject.clustering).to eq((1.0/1.0 + 2.0/3.0) / 6.0)
+    end
+  end
+  describe "PageRank" do
+    it "calculates with two nodes connected" do
+      pr = Graph.new_from_string("source,target,type\n1,2,directed").page_rank
+      expect(pr.first).to be < pr.last
+    end
+    it "calculates with three nodes within a line" do
+      pr = Graph.new_from_string("source,target,type\n1,2,directed\n2,3,directed").page_rank
+      expect(pr[0]).to be < pr[1]
+      expect(pr[1]).to be < pr[2]
+    end
+    it "calculates with two nodes pointing to the same" do
+      pr = Graph.new_from_string("source,target,type\n1,2,directed\n3,2,directed").page_rank
+      expect(pr[0]).to be < pr[1]
+      expect(pr[2]).to be < pr[1]
+      expect(pr[0]).to eq(pr[2])
+    end
+
+    it "calculates with a cycle" do
+      pr = Graph.new_from_string("source,target,type\n1,2,directed\n2,3,directed\n3,1,directed").page_rank
+      expect(pr[0]).to eq(pr[1])
+      expect(pr[1]).to eq(pr[2])
+      expect(pr.inject(:+)).to eq(1)
+    end
+    it "calculates with two subgraphs" do
+      pr = Graph.new_from_string("source,target,type\n1,2,directed\n3,4,directed\n3,1,directed").page_rank
+      expect(pr[0]).to be < pr[1]
+      expect(pr[2]).to be < pr[3]
+    end
   end
 end

data/spec/rgraph/link_spec.rb

@@ -4,7 +4,7 @@ require_relative '../../lib/rgraph/node'
 
 describe Link do
   describe "creates a link without a weight" do
-    subject { Link.new(source: Node.new(id: 00001), target: Node.new(id: 00002), years: [2011, 2012]) }
+    subject { Link.new(source: Node.new(id: 1), target: Node.new(id: 2), years: [2011, 2012]) }
     its(:source) { should be_kind_of Node }
     its(:target) { should be_kind_of Node }
     its(:weight) { should == 1 }
@@ -15,31 +15,38 @@ describe Link do
       expect(subject.target.neighbours).to eq([subject.source])
     end
 
+    it "checks link's direction" do
+      link = Link.new(source: Node.new(id: 1), target: Node.new(id: 2), type: 'directed')
+      expect(link.source.neighbours.count).to eq(1)
+      expect(link.target.neighbours.count).to eq(0)
+    end
+
   end
 
   describe "creates a link passing a weight" do
     subject { Link.new(source: Node.new(id: 00001), target: Node.new(id: 00002), weight: 4, years: [2011, 2012]) }
     its(:weight) { should == 4 }
 
-    it "checks the creation of neighbours" do
-      expect(subject.source.neighbours).to eq([subject.target])
-      expect(subject.target.neighbours).to eq([subject.source])
-    end
   end
 
-  it "creates a link without source" do
+  it "doesn't create a link without source" do
     expect { Link.new(target: Node.new(id: 00001)) }.to raise_exception("source cant be nil")
   end
 
-  it "creates a link without target" do
+  it "doesn't create a link without target" do
     expect { Link.new(source: Node.new(id: 00001)) }.to raise_exception("target cant be nil")
   end
 
-  it "creates a link with wrong source type" do
+  it "doesn't create a link with wrong source type" do
     expect { Link.new(source: "Lucas", target: Node.new(id: 1)) }.to raise_exception("source must be of type Node")
   end
 
-  it "creates a link with wrong target type" do
+  it "doesn't create a link with wrong target type" do
     expect { Link.new(source: Node.new(id: 1), target: "Lucas") }.to raise_exception("target must be of type Node")
   end
+
+  it "sets default type as 'undirected'" do
+    expect(Link.new(source: Node.new(id: 1), target: Node.new(id: 2)).type).to eq('undirected')
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rgraph
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-30 00:00:00.000000000 Z
+date: 2013-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler