graphsrb 0.1.0

data/examples/PrimMST/prim.rb

@@ -0,0 +1,82 @@
+require 'graphsrb'
+include Graphsrb
+
+#Assumption: graph is nonempty connected undirected
+module PrimMST
+  INF = (2**(0.size * 8 -2) -1)
+
+  def self.run(graph)
+    init(graph)
+
+    start = graph.vertices.first
+    include_vertex(start)
+
+    adj_vertices = graph.adjacent_vertices(start)
+    adj_vertices.each do |v|
+      @dist[v.id] = graph.edge(start, v).weight
+      @parent[v.id] = start
+    end
+
+    while not all_vertices_included?
+      v = min_dist_vertex
+      include_vertex(v)
+      update_distances(v)
+    end
+
+    edges = []
+    (0...@parent.size).each do |i|
+      edges << graph.edge(@parent[i], Vertex.new(i)) if @parent[i]
+    end
+    edges
+  end
+
+
+  def self.init(g)
+    @graph = g
+    @vertex_count = g.vertex_count
+    @included_vertex_count = 0
+    @included = []
+    @dist = []
+    @parent = []
+    @graph.vertices.each do |v|
+      @included[v.id] = false
+      @dist[v.id] = INF
+    end
+  end
+
+  def self.included?(v)
+    @included[v.id]
+  end
+
+  def self.include_vertex(v)
+    @included[v.id] = true
+    @included_vertex_count += 1
+  end
+
+  def self.update_distances(v)
+    vertices = @graph.adjacent_vertices(v)
+    vertices.each do |u|
+      edge = @graph.edge(v,u)
+      if !included?(u) && (@dist[u.id] > edge.weight)
+        @dist[u.id] = edge.weight
+        @parent[u.id] = v
+      end
+    end
+  end
+
+  def self.all_vertices_included?
+    @included_vertex_count == @vertex_count
+  end
+
+  def self.min_dist_vertex
+    min = INF
+    vertex = nil
+    @graph.vertices.each do |v|
+      if @dist[v.id] < min && !included?(v)
+        min = @dist[v.id]
+        vertex = v
+      end
+    end
+    vertex
+  end
+end

data/examples/ProbAlgs/LargeCustset/large_cutset.rb

@@ -0,0 +1,59 @@
+require 'graphsrb'
+include Graphsrb
+
+# The problem is finding a large cutset in
+# a simple undirected graph where each edge
+# has weigh equal to 1.
+# This problem is NP-hard.
+module LargeCutset
+
+  def self.run(graph)
+    init(graph)
+    compute_cut
+  end
+
+  def self.init(graph)
+    @graph = graph
+    @pA, @pB = [], []
+  end
+
+  #Monte Carlo algorithm
+  def self.compute_cut
+    prng = Random.new(Time.now.to_i)
+    @graph.vertices.each do |v|
+      if prng.rand(100) < 50
+        @pA << v
+      else
+        @pB << v
+      end
+    end
+    cut_weight
+  end
+
+  def self.cut_weight
+    total_weight = 0
+    @pA.each do |v|
+      @graph.adjacent_vertices(v).each do |u|
+        total_weight += 1 if @pB.include?(u)
+      end
+    end
+    total_weight
+  end
+
+  def self.print_cutset
+    puts "Cutset:"
+    @pA.each do |v|
+      @graph.adjacent_vertices(v).each do |u|
+        puts @graph.edge(v,u) if @pB.include?(u)
+      end
+    end
+  end
+
+  def self.print_partitions
+    print "Partition A: "
+    @pA.each{|v| print "#{v} "}
+    print "\nPartition B: "
+    @pB.each{|v| print "#{v} "}
+    print "\n"
+  end
+end

data/examples/ProbAlgs/LargeCustset/main.rb

@@ -0,0 +1,45 @@
+require_relative 'large_cutset'
+
+def run_example(example_title, graph)
+  puts "------- #{example_title} ------ "
+  puts "The graph has #{graph.vertex_count} vertices and #{graph.edge_count} edges"
+  puts "Cutset size #{LargeCutset.run(graph)}"
+  LargeCutset.print_partitions
+  LargeCutset.print_cutset
+end
+
+
+def main
+  edges = [
+    [1,2], [1,3], [1,5],
+    [2,4], [2,5], [2,6],
+    [3,4], [3,6],
+    [4,5], [4,6],
+    [5,6]
+  ]
+  run_example('Example 1', Graph.new(edges:edges))
+
+  edges = [
+    [1,2], [1,3],
+    [2,4],
+    [3,4],
+    [4,5],
+    [5,6], [5,6],
+    [6,7]
+  ]
+  run_example('Example 2', Graph.new(edges:edges))
+
+  edges = [[1,2],[2,3],[3,4],[4,1],[1,3],[4,2]]
+  run_example('Example 3', Graph.new(edges:edges))
+
+  edges = [
+    [1,2], [1,3], [1,4], [1,5],
+    [2,3], [2,4], [2,5],
+    [3,4], [3,5],
+    [4,5]
+  ]
+  run_example('Example 4', Graph.new(edges:edges))
+
+end
+
+main

data/graphsrb.gemspec

@@ -0,0 +1,39 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "graphsrb/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "graphsrb"
+  spec.version       = Graphsrb::VERSION
+  spec.authors       = ["Bayram Kuliyev"]
+  spec.email         = ["bkuliyev@gmail.com"]
+
+  spec.summary       = %q{This gem allows to create simple directed and undirected graphs. Basic operations allows easily implement graph algorithms}
+  spec.homepage      = "https://github.com/fade2black/graphsrb"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+
+  spec.add_dependency "json", "~> 1.8"
+end

data/lib/graphsrb.rb

@@ -0,0 +1,11 @@
+module Graphsrb; end
+require "graphsrb/version"
+require "graphsrb/exceptions"
+require "graphsrb/vertex"
+require "graphsrb/node"
+require "graphsrb/adjacency_list"
+require "graphsrb/edge"
+require "graphsrb/base_graph"
+require "graphsrb/diedge"
+require "graphsrb/digraph"
+require "graphsrb/graph"

data/lib/graphsrb/adjacency_list.rb

@@ -0,0 +1,78 @@
+
+class Graphsrb::AdjacencyList
+  include Enumerable
+
+  def initialize
+    @adj_list = []
+  end
+
+  #Adds a node to the adjacency list
+  def add(node)
+    adj_list << node.clone
+  end
+
+  #Adds a node to the adjacency list
+  def <<(node)
+    add(node)
+  end
+
+  #Updates weight
+  def update_weight(node, w)
+    node = find(node)
+    node.update_weight(w) unless node.nil?
+  end
+
+  #Increses weight by +dw+
+  def increase_weight(node, dw)
+    node = find(node)
+    node.update_weight(node.weight + dw) unless node.nil?
+  end
+
+  def each(&block)
+    @adj_list.each(&block)
+  end
+
+  #Returns the number of nodes in the adjacency list
+  def size
+    adj_list.size
+  end
+
+  #Removes a node from the adjacency list
+  def delete(node)
+    adj_list.delete(node)
+  end
+
+  #Searches for a node in the adjacency list
+  #Returns nil if not found
+  def find(node)
+    index = adj_list.index node
+    if index.nil?
+      return nil
+    else
+      adj_list[index]
+    end
+  end
+
+  #Returns all nodes
+  def nodes
+    adj_list.clone
+  end
+
+  #Returns true if the adjacency list contains the node, false otherwise
+  def has_node?(node)
+    not find(node).nil?
+  end
+
+  #Remove all nodes from the list
+  def clear
+    adj_list.clear
+  end
+
+  #Creates and returns the created node
+  def self.create_node(vertex_id, args={})
+    Graphsrb::Node.new(vertex_id, args)
+  end
+
+  private
+  attr_reader :adj_list
+end

data/lib/graphsrb/base_graph.rb

@@ -0,0 +1,167 @@
+
+#This class is the base clase for undirected and directed graphs.
+class Graphsrb::BaseGraph
+
+  def initialize(args={})
+    @adj_table = {}
+    args.fetch(:vertices,[]).each{|vertex_id| adj_table[vertex_id] = _create_adjacency_list }
+    args.fetch(:edges,[]).each do |e|
+      unless has_edge?(e[0], e[1])
+        vertices_must_be_different!(e[0], e[1])
+        add_edge(e[0], e[1], weight: e[2] || 1)
+      end
+    end
+  end
+
+  #Returns vertices of the graph
+  def vertices
+    vertex_array = []
+    adj_table.keys.each do |id|
+      vertex_array << _create_vertex(id)
+    end
+    vertex_array
+  end
+
+  #Returns an edge
+  def edge(v, u)
+    id1, id2 = v.id, u.id
+    if has_vertex?(id1)
+      node = adj_table[id1].find(_create_node(id2))
+      return _create_edge(id1, id2, weight:node.weight) if node
+    end
+
+    if has_vertex?(id2)
+      node = adj_table[id2].find(_create_node(id1))
+      return _create_edge(id1, id2, weight:node.weight) if node
+    end
+  end
+
+  #Updates edge weight
+  def update_weight(v, u, w)
+    id1, id2 = v.id, u.id
+    adj_table[id1].update_weight(_create_node(id2), w) if has_vertex?(id1)
+    adj_table[id2].update_weight(_create_node(id1), w) if has_vertex?(id2)
+  end
+
+  #Increases edge weight by +dw+
+  def increase_weight(v, u, dw)
+    id1, id2 = v.id, u.id
+    adj_table[id1].increase_weight(_create_node(id2), dw) if has_vertex?(id1)
+    adj_table[id2].increase_weight(_create_node(id1), dw) if has_vertex?(id2)
+  end
+
+  #Returns edges of the graph
+  def edges
+    edges_array = []
+    vertices.each do |vertex|
+      adj_table[vertex.id].each do |node|
+        edges_array << _create_edge(vertex.id, node.vertex.id, weight: node.weight)
+      end
+    end
+    edges_array
+  end
+
+  #Removes all vertices and edges.
+  def clear
+    adj_table.each_value{|list| list.clear}
+    @adj_table = {}
+    true
+  end
+
+  ##Creates a copy of the graph
+  def copy
+    Marshal::load(Marshal.dump(self))
+  end
+
+  #Returns the number of vertices
+  def vertex_count
+    vertices.size
+  end
+
+  #Returns the number of edges in the graph
+  def edge_count
+    sum = 0
+    adj_table.each_value{|list| sum += list.size}
+    sum
+  end
+
+  #Checks whether the graph has a vertex
+  def has_vertex?(id)
+    not adj_table[id].nil?
+  end
+
+  alias vertex? has_vertex?
+
+  #Checks whether the graph has an edge
+  def has_edge?(id1, id2)
+    has_vertex?(id1) && adj_table[id1].has_node?(_create_node(id2)) ||
+    has_vertex?(id2) && adj_table[id2].has_node?(_create_node(id1))
+  end
+
+  alias edge? has_edge?
+
+  #Adds a new vertex
+  def add_vertex(id)
+    return nil if has_vertex?(id)
+    adj_table[id] = _create_adjacency_list
+    true
+  end
+
+  #Adds a new edge
+  def add_edge(id1, id2, args={})
+    vertices_must_be_different!(id1, id2)
+    return nil if has_edge?(id1, id2)
+    add_vertex(id1) unless has_vertex?(id1)
+    add_vertex(id2) unless has_vertex?(id2)
+    adj_table[id1] << _create_node(id2, args)
+    true
+  end
+
+  #Remove an edge from the graph
+  def remove_edge(v1, v2)
+    id1, id2 = v1.id, v2.id
+    adj_table[id1].delete(_create_node(id2)) if has_vertex?(id1)
+    adj_table[id2].delete(_create_node(id1)) if has_vertex?(id2)
+    true
+  end
+
+  #Remove a vertex from the graph
+  def remove_vertex(v)
+    id = v.id
+    return nil unless has_vertex?(id)
+
+    adj_table[id].clear
+    adj_table.delete(id)
+
+    node = _create_node(id)
+    adj_table.each_value{|list| list.delete(node)}
+    return v
+  end
+
+
+  protected
+  attr_reader :adj_table
+
+  def _create_node(vertex_id, args={})
+    Graphsrb::Node.new(vertex_id, args)
+  end
+
+  def _create_adjacency_list
+    Graphsrb::AdjacencyList.new
+  end
+
+  def _create_edge(id1, id2, args={})
+    Graphsrb::Edge.new(id1, id2, args)
+  end
+
+  def _create_vertex(id)
+    Graphsrb::Vertex.new(id)
+  end
+
+  def vertices_must_be_different!(id1, id2)
+    if id1 == id2
+      raise Graphsrb::EdgeInitializationError, "Vertex id's must be different from each other"
+    end
+  end
+
+end