petri_net_2020 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 84efe45538b89da15a248ef1c52cfb8ffe686c1b432979f52914e3b9db978a4f
+  data.tar.gz: c19c84722a8071d9ab7e0e076b05390b2a14826e36b653da149447de03eee4d8
+SHA512:
+  metadata.gz: 73f04577f5c74c937a5e0a912e0c047dbea201e9957f3dc5d8b4965bba5d808ad21e0a14b53148b67bc0ee36258d25a2f7beff3f897e509ebd55320bd812b6fb
+  data.tar.gz: 14712b4c660e8435f8c38556dde62c859267edc74a02254e43249a4f6616e8b0858feba60917e051b6904f40dae0b7078b3b82b0463af0b0b38622e3ca557c9e

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+pkg/*.gem

data/.ruby-version

@@ -0,0 +1 @@
+2.6

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+rvm:
+- 1.9.3
+- jruby-19mode # JRuby in 1.9 mode
+- 2.0.0
+
+before_install:
+    - gem install net-sftp
+    - sudo apt-get install graphviz
+
+script: 
+    - rake test

data/CHANGELOG

@@ -0,0 +1,8 @@
+2009-08-14	Brian D. Nelson	<bdnelson@wildcoder.com>
+* Initial project creation.
+
+2010-08-26  Brian D. Nelson <bdnelson@wildcoder.com>
+* Restart of project
+
+2013-13.12 Christian Clausen <cclausen@tzi.de>
+* Fork project to create a petrinet library to use for my Bachelor-Thesis

data/Gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in petri.gemspec
+gemspec
+gem 'rake'
+gem 'rgl', "~>0.5.6"
+#gem 'rgl', git: 'https://github.com/monora/rgl.git'

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2013, Christian Clausen (cclausen@tzi.de)
+
+Copyright (c) 2009, Brian D. Nelson (bdnelson@wildcoder.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,97 @@
+{<img src="https://travis-ci.org/cclausen/petri_net.png" />}[https://travis-ci.org/cclausen/petri_net]
+
+{<img src="https://codeclimate.com/github/cclausen/petri_net.png" />}[https://codeclimate.com/github/cclausen/petri_net]
+
+= PTNet: Petri-net Simulation in Ruby
+===== based on the code by Brian D Nelson <bdnelson@wildcoder.com>
+===== Christian Clausen <cclausen@tzi.de>
+
+== Version 0.6
+I implemented most of the basics you need for playing with PetriNets but there are a lot things to add.
+Next big step will be a stochastic analysis of the PetriNet.
+
+== Overview
+This package provides a ruby based simulation package for Petri nets.
+You can build PetriNets, fire transitions and calculate statistica or solve problems in the net.
+It also provides a visualization of the net (and even the Reachability Graph of the given net)
+
+
+== Petri Net Resources
+* http://en.wikipedia.org/wiki/Petri_net - Wikipedia
+
+== Usage
+=== Creation
+At first you need to create a blank petrinet:
+    net = PetriNet::Net.new
+Then you can add places and transitions:
+    net << PetriNet::Place.new
+    net << PetriNet::Transition.new
+It's a good idea to name the places and transitions, as you need to refer to them to add, so the better way will be:
+    net << PetriNet::Place.new(name: "A")
+    net << PetriNet::Transition.new(name: "a")
+    net << PetriNet::Arc.new(source: "A", destination: "a")
+As you see, an arc needs to get a source and a destination. You can, but you don't need to name your arcs, as you don't need to refer to them later in most cases.
+You can get a place/transition/arc by
+    net.get_place( name )
+    net.get_transition( name )
+    net.get_arc( name )
+Or if you know the id (but not the name) you can use
+    net.get_object(id)
+Of course you can save the Objects while creating them and add them afterwards:
+    place_B = PetriNet::Place.new(name: "B")
+    net << place_B
+or
+    net.add_object place_B
+or
+    net.add_place place_B
+if you want to use this.
+PetriNet#add_object even accepts arrays of accepted objects
+
+To create an arc you do not need to specify source and destination, you can add them with "add_source" and "add_destination" later on, but an arc has to have both before being added to a net.
+
+=== Markings
+ !!! Attention, I'm not sure how I will implement markings in the end, this part might be wrong because I changed something. I'm not happy with the way I handle markings/token currently. Currently are PetriNet::Base-Objects which makes no sence in my opinion.
+
+ !!! Attention, Markings are inconsistens at the moment. In the original code markings are what I call "token" or "tokken" and a marking is the "state" of a petrinet, which means how many token are in which places. It's hard to understand which markings are meant as currently everything is called "marking" I will refactor this some time.
+
+You can create markings like other PetriNet::Base objects with
+    marking = PetriNet::Marking.new
+And add them to a place with
+    place_B.add_marking(marking)
+
+But since I see no sence in creating the specific markings you can do
+    place_B.add_marking(3)
+to add three markings to a place. Without any argument it will add just one marking.
+
+You can get the current marking with net.get_markings. This will give you an Array of state-markings. [1,3,2,4] would mean, the first place (in order of id's, but be careful, every PetriNet::Base-object has a unique id) will hold one marking (or token) the second place will hold 3 and so on.
+You can even set the markings with
+    net.set_markings([1,3,2,4]
+but be carefull with this one, maybe this should be private in future but it can be very usefull to save the initial state or to set the net to a specific state for some algorithms (e.g. for generating the Reachability Graph)
+
+=== Visualization
+You can just print yout PetriNet with
+    net.to_s
+as you should know this means you can write
+    puts net
+
+For a more fancy way to show off with your PetriNet you should try
+    net.to_gv
+which generates the GraphViz-Code for the PetriNet.
+It is planned to use the GraphViz-gem in the future to create png and stuff like that directly.
+
+=== Reachability Graph
+The Reachablility Graph is a Graph with nodes representing reachable markings of the net in the current state and edges reresenting the transitions you need to get from one node to another.
+You can generate the reachablility Graph with
+    net.generate_reachability_graph
+As a PetriNet itself you can to_s and to_gv the reachablility Graph too.
+
+=== More documentation will come soon
+
+== Contributing
+Neither the library nor the documentation is finished by now, so please feel free to contribute
+
+Just write an email and/or fork this project. Active contributors will get write-access to this repository too.
+
+
+== Gem
+This library is available on rubygems.org soon

data/Rakefile

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+begin
+  require "bundler/setup"
+rescue LoadError
+  puts "You must `gem install bundler` and `bundle install` to run rake tasks"
+end
+
+require "rdoc/task"
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title    = "Wf"
+  rdoc.options << "--line-numbers"
+  rdoc.rdoc_files.include("README.md")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+
+
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = false
+end
+
+task default: :test

data/lib/petri_net/arc.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module PetriNet
+  # Arc
+  class Arc < PetriNet::Base
+    # Unique ID
+    attr_reader   :id
+    # human readable name
+    attr_accessor :name
+    # Description
+    attr_accessor :description
+    # Arc weight
+    attr_accessor :weight
+    # Source-object
+    attr_reader   :source
+    # Source-object
+    attr_reader   :destination
+    # The net this arc belongs to
+    attr_writer   :net
+
+    # Creates an arc.
+    # An arc is an directed edge between a place and a transition (or visa versa) and can have a weight which indicates how many token it comsumes or produces from/to the place
+    def initialize(options = {}, &block)
+      @id = next_object_id
+      @name = (options[:name] || "Arc#{@id}")
+      @description = (options[:description] || "Arc #{@id}")
+      @weight = (options[:weight] || 1)
+      add_source(options[:source]) unless options[:source].nil?
+      add_destination(options[:destination]) unless options[:destination].nil?
+
+      yield self unless block.nil?
+    end
+
+    # Add a source object to this arc.  Validation of the source object will be performed
+    # before the object is added to the arc and an exception will be raised.
+    def add_source(object)
+      if object.class.to_s == 'String'
+        object = (@net.get_place(object) || @net.get_transition(object))
+      end
+      if validate_source_destination(object)
+        @source = object
+        object.add_output(self)
+      else
+        raise "Invalid arc source object: #{object.class}"
+      end
+    end
+
+    # Add a destination object
+    def add_destination(object)
+      if object.class.to_s == 'String'
+        object = (@net.get_place(object) || @net.get_transition(object))
+      end
+      if validate_source_destination(object)
+        @destination = object
+        object.add_input(self)
+      else
+        raise "Invalid arc destination object: #{object.class}"
+      end
+    end
+
+    # A Petri Net is said to be ordinary if all of its arc weights are 1's.
+    # Is this arc ordinary?
+    def ordinary?
+      @weight == 1
+    end
+
+    # Validate this arc.
+    def validate(net)
+      return false if @id < 1
+      return false if @name.nil? || (@name.length <= 0)
+      return false if @weight < 1
+      return false if @source.nil? || @destination.nil?
+      return false if @source == @destination
+      return false if @source.class == @destination.class
+
+      if @source.class.to_s == 'PetriNet::Place'
+        return net.objects_include? @source
+      elsif @source.class.to_s == 'PetriNet::Transition'
+        return net.objects_include? @source
+      else
+        return false
+      end
+      if @destination.class.to_s == 'PetriNet::Place'
+        return net.objects.include? @destination
+      elsif @destination.class.to_s == 'PetriNet::Transition'
+        return net.objects.include? @destination
+      else
+        return false
+      end
+
+      true
+    end
+
+    # Stringify this arc.
+    def to_s
+      "#{@id}: #{@name} (#{@weight}) #{@source.id} -> #{@destination.id}"
+    end
+
+    # Gives the GraphViz-representation of this arc as string of a GV-Edge
+    def to_gv
+      "\t#{@source.gv_id} -> #{@destination.gv_id} [ label = \"#{@name}\", headlabel = \"#{@weight}\" ];\n"
+    end
+
+    # Checks if the information in this arc are still correct.
+    # The information can get wrong if you merge two nets together.
+    def need_update?(net)
+      if net.get_object(@source.id).nil? || (@source.name != net.get_object(@source.id).name)
+        return true
+      end
+      if net.get_object(@destination.id).nil? || (@destination.name != net.get_object(@destination.id).name)
+        return true
+      end
+    end
+
+    # Updates the information in this arc
+    # Should only be necessary if PetriNet::Arc#need_update? is true
+    # affects source and destination
+    def update(net)
+      @source.id = net.objects_find_index @source
+      @destination.id = net.objects_find_index @destination
+    end
+
+    def <=>(object)
+      return false unless object.class.to_s == 'PetriNet::Arc'
+      return false unless object.source == source && object.destination == destination
+
+      object.weight <=> weight
+    end
+
+    private
+
+    # Validate source or destination object
+    def validate_source_destination(object)
+      return false if object.nil?
+
+      return object.class.to_s == 'PetriNet::Place' || object.class.to_s == 'PetriNet::Transition'
+
+      # return if @source.nil? or @source.class.to_s == object.class.to_s
+      # return if @destination.nil? or @destination.class.to_s == object.class.to_s
+      true
+    end
+  end
+end

data/lib/petri_net/base.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module PetriNet
+  # Common structure
+  class Base
+    # Accepts a logger conforming to the interface of Log4r or the default Ruby 1.8+ Logger class.
+    attr_accessor :logger
+
+    # Global object count.
+    @@object_count = 0
+
+    # Initialize the base class.
+    def initialize(_options = {})
+      @logger = Logger.new(STDOUT)
+      @logger.level = Logger::INFO
+    end
+
+    # Get the next object ID (object count).
+    def next_object_id
+      @@object_count += 1
+    end
+
+    # Resets the object-count
+    # This should not be used without extreme care
+    # It's made for testing-purposes only
+    def reset
+      @@object_count = 0
+    end
+  end
+end

data/lib/petri_net/coverability_graph/edge.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class PetriNet::CoverabilityGraph::Edge < PetriNet::Base
+  # Creates an edge for PetriNet::CoverabilityGraph
+  def initialize(options = {}, &block)
+    super(options)
+    yield self unless block.nil?
+  end
+
+  # Validates the data holded by this edge, this will be used while adding the edge to the graph
+  def validate
+    super
+  end
+end

data/lib/petri_net/coverability_graph/graph.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'graphviz'
+
+class PetriNet::CoverabilityGraph < PetriNet::Base
+  def initialize(net, options = {})
+    @objects = []
+    @nodes = {}
+    @edges = {}
+    @name = net.name
+    @unlimited = if options['unlimited'].nil?
+                   true
+                 else
+                   options['unlimited']
+                 end
+  end
+
+  def add_node(node)
+    double = false
+    inf = false
+    @nodes.each_value do |n|
+      if node > @objects[n]
+        if @unlimited
+          double = n
+          break
+          # return @objects[n].id *-1
+        else
+          raise PetriNet::Graph::InfiniteReachabilityGraphError
+          end
+      end
+      inf = true if -Float::INFINITY == (node <=> @objects[n])
+    rescue ArgumentError
+      # just two different markings, completly ok
+    end
+    # if there was a smaller marking
+    return (@objects[double].id * -1) if double
+
+    node_index = @objects.index node
+    # if there already is a node with this marking
+    return @objects[node_index].id * -1 unless node_index.nil?
+
+    return -Float::INFINITY if inf
+
+    if node.validate && (!@nodes.include? node.name)
+      @objects[node.id] = node
+      @nodes[node.name] = node.id
+      node.graph = self
+      return node.id
+    end
+    false
+  end
+end

data/lib/petri_net/coverability_graph/node.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+class PetriNet::CoverabilityGraph::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(options = {}, &block)
+    @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
+
+  # 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]
+    end
+    @omega_marked = true
+    ret
+  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::CoverabilityGraph::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/coverability_graph.rb

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

data/lib/petri_net/graph/edge.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+class PetriNet::Graph::Edge < PetriNet::Base
+  # Human readable name
+  attr_reader :name
+  # Unique ID
+  attr_reader :id
+  # Graph this edge belongs to
+  attr_accessor :graph
+  # Probability of the relating transition
+  attr_accessor :probability
+  # Source of the edge
+  attr_reader :source
+  # Destination of the edge
+  attr_reader :destination
+  # Transition this edge is representing
+  attr_reader :transition
+
+  # Creates an edge for PetriNet::Graph
+  def initialize(graph, options = {}, &block)
+    @graph = graph
+    @id = next_object_id
+    @name = (options[:name] || "Edge#{@id}")
+    @description = (options[:description] || "Edge #{@id}")
+    @source = options[:source]
+    @destination = options[:destination]
+    @label = (options[:label] || @name)
+    @probability = options[:probability]
+    @transition = (options[:transition] || '')
+
+    yield self unless block.nil?
+  end
+
+  # Validates the data holded by this edge, this will be used while adding the edge to the graph
+  def validate
+    return false unless @graph.nodes.key?(@source.name) && @graph.nodes.key?(@destination.name)
+
+    true
+  end
+
+  def to_gv
+    "\t#{@source.gv_id} -> #{@destination.gv_id}#{probability_to_gv};\n"
+  end
+
+  def ==(object)
+    return false unless object.class.to_s == 'PetriNet::ReachabilityGraph::Edge'
+
+    (@source == object.yource && @destination == oject.destination)
+  end
+
+  def to_s
+    "#{@id}: #{@name} #{@source} -> #{@destination} )"
+  end
+
+  private
+
+  def probability_to_gv
+    if @probability
+      " [ label = \"#{@probability}\" ] "
+    else
+      ''
+    end
+  end
+end