petri_net_2020 1.0.0

data/lib/petri_net/graph/graph.rb

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+require 'graphviz'
+require 'graphviz/theory'
+require 'rgl/adjacency'
+require 'rgl/dijkstra'
+class PetriNet::InfiniteReachabilityGraphError < RuntimeError
+end
+
+class PetriNet::Graph < PetriNet::Base
+  # The PetriNet this graph belongs to
+  attr_reader :net
+  # all nodes from this graph
+  attr_reader :nodes
+  # all edges of this graph
+  attr_reader :edges
+
+  def initialize(net, options = {})
+    @net = net
+    @objects = []
+    @nodes = {}
+    @edges = {}
+    @name = net.name
+    @type = 'Reachability'
+    @unlimited = if options['unlimited'].nil?
+                   true
+                 else
+                   options['unlimited']
+                 end
+  end
+
+  def add_node(node)
+    if node.validate && (!@objects.include? node)
+      @objects[node.id] = node
+      @nodes[node.name] = node.id
+      node.graph = self
+      return node.id
+    end
+    if @objects.include? node
+      res = (@objects.index node) * -1
+      return res
+    end
+    false
+  end
+  alias add_node! add_node
+
+  def add_edge(edge)
+    if edge.validate && (!@edges.include? edge.name)
+      @objects[edge.id] = edge
+      @edges[edge.name] = edge.id
+      edge.graph = self
+      edge.source.outputs << edge.id
+      edge.destination.inputs << edge.id
+      return edge.id
+    end
+    false
+  end
+
+  def get_edge(source, dest)
+    res = nil
+    @edges.each_value do |edge|
+      if @objects[edge].source == source && @objects[edge].destination == dest
+        res = @objects[edge]
+      end
+    end
+    res
+  end
+
+  # Add an object to the Graph.
+  def <<(object)
+    case object.class.to_s
+    when 'Array'
+      object.each { |o| self << o }
+    when 'PetriNet::ReachabilityGraph::Edge'
+      add_edge(object)
+    when 'PetriNet::ReachabilityGraph::Node'
+      add_node(object)
+    else
+      raise "(PetriNet::ReachabilityGraph) Unknown object #{object.class}."
+    end
+    self
+  end
+  alias add_object <<
+
+  def get_node(node)
+    return @objects[node] if node.class.to_s == 'Fixnum'
+    if node.class.to_s == 'Array'
+      return @objects.select { |o| o.class.to_s == 'PetriNet::ReachabilityGraph::Node' && o.markings == node }.first
+    end
+  end
+
+  def get_object(id)
+    @objects[id]
+  end
+
+  def get_nodes
+    res = []
+    @nodes.each_value do |n|
+      res << @objects[n]
+    end
+    res
+  end
+
+  def infinite?
+    @nodes.each_value do |node|
+      return true if @objects[node].infinite?
+    end
+    false
+  end
+
+  def to_gv(output = 'png', filename = '')
+    g = generate_gv
+    filename = "#{@name}_graph.png" if filename.empty?
+    g.output(png: filename) if output == 'png'
+    g.output
+  end
+
+  def generate_gv(named = true)
+    g = GraphViz.new(:G, type: :digraph)
+
+    @nodes.each_value do |node|
+      label = if named
+                (@net.get_place_from_marking @objects[node].markings).to_s
+              else
+                @objects[node].markings.to_s
+              end
+      gv_node = g.add_nodes(label)
+      gv_node.set do |n|
+        n.label = '*' + label + '*' if @objects[node].start
+      end
+    end
+    @edges.each_value do |edge|
+      label1 = if named
+                 (@net.get_place_from_marking @objects[edge].source.markings).to_s
+               else
+                 @objects[edge].source.markings.to_s
+               end
+
+      label2 = if named
+                 (@net.get_place_from_marking @objects[edge].destination.markings).to_s
+               else
+                 @objects[edge].destination.markings.to_s
+               end
+      gv_edge = g.add_edges(label1, label2)
+      gv_edge.set do |e|
+        e.label = @objects[edge].transition
+      end
+    end
+    @gv = g
+  end
+
+  def generate_rgl
+    g = RGL::DirectedAdjacencyGraph.new
+    @nodes.each_value do |node|
+      g.add_vertex @objects[node].markings.to_s
+    end
+    @edges.each_value do |edge|
+      g.add_edge @objects[edge].source.markings.to_s, @objects[edge].destination.markings.to_s
+    end
+    @rgl = g
+  end
+
+  def to_s
+    str = "#{@type} Graph [#{@name}]\n"
+    str += "----------------------------\n"
+    str += "Description: #{@description}\n"
+    str += "Filename: #{@filename}\n"
+    str += "\n"
+
+    str += "Nodes\n"
+    str += "----------------------------\n"
+    @nodes.each_value { |p| str += @objects[p].to_s + "\n" }
+    str += "\n"
+
+    str += "Edges\n"
+    str += "----------------------------\n"
+    @edges.each_value { |t| str += @objects[t].to_s + "\n" }
+    str += "\n"
+
+    str
+  end
+
+  def get_rgl
+    generate_rgl if @rgl.nil?
+    @rgl
+  end
+
+  def cycles
+    get_rgl.cycles
+  end
+
+  def shortest_path(start, destination)
+    g = get_rgl
+    weights = ->(_edge) { 1 }
+    g.dijkstra_shortest_path(weights, start.to_s, destination.to_s)
+  end
+
+  def path_probability(path)
+    sanitize_probabilities
+    prob = 1
+    counter = 0
+    path.each do |node|
+      edge = get_edge(path[counter + 1], node)
+      prob *= edge.probability unless edge.nil? # last node has no pre-edge
+      counter = counter += 1
+    end
+    prob
+  end
+
+  def node_probability(start, node)
+    paths = get_paths_without_loops(start, node)
+    prob = 0
+    paths.each do |path|
+      prob += (path_probability path)
+    end
+    prob
+  end
+
+  def best_path(start, node)
+    paths = get_paths_without_loops(start, node)
+    prob = 0
+    res_path = nil
+    paths.each do |path|
+      if (path_probability path) >= prob
+        prob = (path_probability path)
+        res_path = path
+      end
+    end
+    [res_path, prob]
+  end
+
+  def worst_path(start, node)
+    paths = get_paths_without_loops(start, node)
+    prob = 1
+    res_path = nil
+    paths.each do |path|
+      if (path_probability path) <= prob
+        prob = (path_probability path)
+        res_path = path
+      end
+    end
+    [res_path, prob]
+  end
+
+  def get_most_relative_influence_on_path(start, node, factor = 0.5)
+    prob_counter = 0
+    prob_diff = []
+    paths = get_paths_without_loops(start, node)
+    paths.each do |path|
+      counter = 0
+      path.each do |curr_node|
+        prob_before = node_probability start, node
+        next if node == path[-1]
+
+        edge = get_edge(path[counter + 1], curr_node)
+        save = edge.probability unless edge.nil?
+        edge.probability += (1 - edge.probability) * factor unless edge.nil?
+        prob_after = node_probability start, node unless edge.nil?
+        edge.probability = save unless edge.nil?
+        prob_diff[prob_counter] = [prob_after - prob_before, [curr_node, path[counter + 1]]] unless edge.nil?
+        prob_counter += 1 unless edge.nil?
+        counter += 1
+      end
+    end
+    prob_diff.max { |x, y| x[0] <=> y[0] }
+  end
+
+  def get_most_absolute_influence_on_path(start, node, sum = 0.01)
+    prob_counter = 0
+    prob_diff = []
+    paths = get_paths_without_loops(start, node)
+    paths.each do |path|
+      counter = 0
+      path.each do |curr_node|
+        prob_before = node_probability start, node
+        next if node == path[-1]
+
+        edge = get_edge(path[counter + 1], curr_node)
+        save = edge.probability unless edge.nil?
+        edge.probability = edge.probability + sum unless edge.nil?
+        edge.probability = 1 if !edge.nil? && edge.probability > 1
+        prob_after = node_probability start, node unless edge.nil?
+        edge.probability = save unless edge.nil?
+        prob_diff[prob_counter] = [prob_after - prob_before, [curr_node, path[counter + 1]]] unless edge.nil?
+        prob_counter += 1 unless edge.nil?
+        counter += 1
+      end
+    end
+    prob_diff.max { |x, y| x[0] <=> y[0] }
+  end
+
+  def get_paths_without_loops(start, goal)
+    get_paths_without_loops_helper(get_node(start), get_node(goal))
+  end
+
+  def sanitize_probabilities
+    @nodes.each_value do |node|
+      prob = 1.0
+      @objects[node].outputs.each do |edge|
+        prob += @objects[edge].probability unless @objects[edge].probability.nil?
+      end
+      @objects[node].outputs.each do |edge|
+        @objects[edge].probability = prob / @objects[node].outputs.size if @objects[edge].probability.nil?
+      end
+    end
+  end
+
+  private
+
+  def get_paths_without_loops_helper(start, goal, reverse_paths = [], reverse_path = [])
+    if goal == start
+      reverse_path << goal
+      reverse_paths << reverse_path
+      return nil
+    end
+    return nil if reverse_path.include? goal
+
+    path = []
+    goal.inputs.each do |input|
+      get_paths_without_loops_helper(start, @objects[input].source, reverse_paths, reverse_path.clone << goal)
+    end
+    reverse_paths
+  end
+end

data/lib/petri_net/graph/node.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+class PetriNet::Graph::Node < PetriNet::Base
+  include Comparable
+
+  # human readable name
+  attr_reader :name
+  # unique ID
+  attr_reader :id
+  # Makking this node represents
+  attr_reader :markings
+  # The graph this node belongs to
+  attr_accessor :graph
+  # Omega-marked node (unlimited Petrinet -> coverabilitygraph)
+  attr_reader :omega_marked
+  # Incoming edges
+  attr_reader :inputs
+  # Outgoing edges
+  attr_reader :outputs
+  # Label of the node
+  attr_reader :label
+  # True if this is the start-marking
+  attr_reader :start
+
+  def initialize(graph, options = {}, &block)
+    @graph = graph
+    @id = next_object_id
+    @name = (options[:name] || "Node#{@id}")
+    @description = (options[:description] || "Node #{@id}")
+    @inputs = []
+    @outputs = []
+    @label = (options[:label] || @name)
+    @markings = options[:markings]
+    @start = (options[:start] || false)
+    raise ArgumentError, 'Every Node needs markings' if @markings.nil?
+
+    @omega_marked = if @markings.include? Float::INFINITY
+                      true
+                    else
+                      false
+                    end
+
+    yield self unless block.nil?
+  end
+
+  def infinite?
+    @omega_marked
+  end
+
+  # Add an omega-marking to a specified place
+  def add_omega(object)
+    ret = []
+    if object.class.to_s == 'PetriNet::CoverabilityGraph::Node'
+      if self < object
+        counter = 0
+        object.markings.each do |marking|
+          if @markings[counter] < marking
+            @markings[counter] = Float::INFINITY
+            ret << counter
+            end
+          counter += 1
+        end
+      else
+        return false
+      end
+    elsif object.class.to_s == 'Array'
+      object.each do |place|
+        markings[place] = Float::INFINITY
+        ret = object
+      end
+    elsif object.class.to_s == 'Fixnum'
+      markings[object] = Float::INFINITY
+      ret = [object]
+    elsif object.class.to_s == 'PetriNet::ReachabilityGraph::Node'
+      raise PetriNet::Graph::InfinityError('ReachabilityGraphs do not support omega-markings')
+    end
+    @omega_marked = true
+    ret
+  end
+
+  def include_place(place)
+    places = @graph.net.get_place_list
+    included_places = []
+    i = 0
+    @markings.each do |m|
+      included_places << places[i] if m > 0
+      i += 1
+    end
+    included_places.include? place
+  end
+
+  def validate
+    true
+  end
+
+  def gv_id
+    "N#{@id}"
+  end
+
+  def to_gv
+    "\t#{gv_id} [ label = \"#{@markings}\" ];\n"
+  end
+
+  # Compare-operator, other Operators are available through comparable-mixin
+  def <=>(object)
+    return nil unless object.class.to_s == 'PetriNet::ReachabilityGraph::Node'
+    return 0 if @markings == object.markings
+
+    counter = 0
+    less = true
+    markings.each do |marking|
+      if marking <= object.markings[counter] && less
+        less = true
+      else
+        less = false
+        break
+      end
+      counter += 1
+    end
+    return -1 if less
+
+    counter = 0
+    more = true
+    markings.each do |marking|
+      if marking >= object.markings[counter] && more
+        more = true
+      else
+        more = false
+        break
+      end
+      counter += 1
+    end
+    return 1 if more
+
+    nil
+  end
+
+  def to_s
+    "#{@id}: #{@name} (#{@markings})"
+  end
+end

data/lib/petri_net/graph.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'graph/graph'
+require_relative 'graph/node'
+require_relative 'graph/edge'
+class PetriNet::Graph < PetriNet::Base
+end

data/lib/petri_net/marking.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module PetriNet
+  # Marking
+  class Marking < PetriNet::Base
+    # depricated
+    attr_accessor :id # Unique ID
+    # depricated
+    attr_accessor :name # Human readable name
+    # depricated
+    attr_accessor :description # Description
+    # depricated
+    attr_accessor :timestep # Marking timestep
+
+    # Create a new marking.
+    # depricated
+    def initialize(_options = {}, &block)
+      yield self unless block.nil?
+    end
+
+    # Validate this marking.
+    def validate; end
+
+    # Stringify this marking.
+    def to_s; end
+  end
+end