y_petri 2.1.3 → 2.1.6

data/lib/y_petri/net/state.rb

@@ -1,121 +1,129 @@
 # encoding: utf-8
 
-class YPetri::Net
-  # Petri net state (marking of all its places).
-  #
-  class State < Array
-    require_relative 'state/feature'
-    require_relative 'state/features'
+# An array whose elements correspond to the full marking of the net's places.
+#
+class YPetri::Net::State < Array
+  require_relative 'state/feature'
+  require_relative 'state/features'
 
-    class << self
-      # Customization of the parametrize method for the State class: Its
-      # dependents Feature and Features (ie. feature set) are also parametrized.
-      # 
-      def parametrize net: (fail ArgumentError, "No owning net!")
-        Class.new( self ).tap do |subclass|
-          subclass.define_singleton_method :net do net end
-          subclass.param_class( { Feature: Feature,
-                                  Features: Features },
-                                with: { State: subclass } )
-        end
+  class << self
+    # Customization of the parametrize method for the State class: Its
+    # dependents Feature and Features (ie. feature set) are also parametrized.
+    # 
+    def parametrize net: ( fail ArgumentError, "No owning net!" )
+      Class.new( self ).tap do |ç|
+        ç.define_singleton_method :net do net end
+        ç.param_class( { Feature: Feature,
+                         Features: Features },
+                       with: { State: ç } )
       end
+    end
 
-      delegate :Marking,
-               :Firing,
-               :Gradient,
-               :Flux,
-               :Delta,
-               to: "Feature()"
-
-      alias __new__ new
-
-      # Revives a state from a record and a given set of marking clamps.
-      # 
-      def new record, marking_clamps: {}
-        cc = marking_clamps.with_keys { |k| net.place k }.with_values! do |v|
-          case v
-          when YPetri::Place then v.marking
-          when ~:call then v.call
-          else v end
-        end
-
-        record = features( marking: net.pp - cc.keys ).load( record )
+    delegate :Marking,
+             :Firing,
+             :Gradient,
+             :Flux,
+             :Delta,
+             to: "Feature()"
 
-        __new__ net.pp.map do |p|
-          begin; cc.fetch p; rescue IndexError
-            record.fetch Marking().of( p )
-          end
+    # Returns the feature identified by the argument.
+    # 
+    def feature *id
+      fail ArgumentError, "No feature identifier!" if id.empty?
+      case id.first
+      when Feature() then id.first
+      when Feature then id.first.class.new( id.first )
+      else
+        msg = "Malformed feature identifier!"
+        fail ArgumentError, msg unless id.size == 1 and id.first.is_a? Hash
+        ꜧ = id.first
+        fail ArgumentError, msg unless ꜧ.size == 1
+        key, val = ꜧ.keys.first, ꜧ.values.first
+        recognized = :marking, :firing, :gradient, :flux, :delta
+        msg = "Unrecognized feature: #{key}"
+        fail ArgumentError, msg unless recognized.include? key
+        # And now, with everything clean...
+        case key
+        when :marking then Marking( val )
+        when :firing then Firing( val )
+        when :flux then Flux( val )
+        when :gradient then Gradient( *val )
+        when :delta then Delta( *val )
         end
       end
+    end
 
-      # Returns the feature identified by the argument.
-      # 
-      def feature id
-        case id
-        when Feature() then id
-        when Feature then id.class.new( id )
-        else
-          features( id ).tap do |ff|
-            ff.size == 1 or fail ArgumentError, "Argument #{id} must identify " +
-                                 "exactly 1 feature!"
-          end.first
-        end
+    # If the argument is an array of features, or another Features instance,
+    # a feature set based on this array is returned. But the real purpose of
+    # this method is to allow hash-type argument, with keys +:marking+,
+    # +:firing+, +:gradient+, +:flux+ and +:delta+, specifying the respective
+    # features. For +:marking+, an array of places (or Marking features) is
+    # expected. For +:firing+ and +:flux+, an array of transitions (or Firing
+    # / Flux features) is expected. For +:gradient+ and +:delta+, a hash value
+    # is expected, containing keys +:places+ and +:transitions+, specifying
+    # for which place set / transition set should gradient / delta features
+    # be constructed. More in detail, values supplied under keys +:marking+,
+    # +:firing+, +:gradient+, +:flux+ and +:delta+ are delegated to
+    # +Features.marking+, +Features.firing+, +Features.gradient+ and
+    # +Features.flux+ methods, and their results are joined into a single
+    # feature set.
+    # 
+    def features arg
+      case arg
+      when Features(), Array then Features().new( arg )
+      else # the real job of the method
+        marking = arg[:marking] || []
+        firing = arg[:firing] || [] # array of tS transitions
+        gradient = arg[:gradient] || [ [], transitions: [] ]
+        flux = arg[:flux] || [] # array of TS transitions
+        delta = arg[:delta] || [ [], transitions: [] ]
+        [ Features().marking( marking ),
+          Features().firing( firing ),
+          Features().gradient( *gradient ),
+          Features().flux( flux ),
+          Features().delta( *delta ) ].reduce :+
       end
+    end
 
-      # If the argument is an array of features, or another Features instance,
-      # a feature set based on this array is returned. But the real purpose of
-      # this method is to allow hash-type argument, with keys +:marking+,
-      # +:firing+, +:gradient+, +:flux+ and +:delta+, specifying the respective
-      # features. For +:marking+, an array of places (or Marking features) is
-      # expected. For +:firing+ and +:flux+, an array of transitions (or Firing
-      # / Flux features) is expected. For +:gradient+ and +:delta+, a hash value
-      # is expected, containing keys +:places+ and +:transitions+, specifying
-      # for which place set / transition set should gradient / delta features
-      # be constructed. More in detail, values supplied under keys +:marking+,
-      # +:firing+, +:gradient+, +:flux+ and +:delta+ are delegated to
-      # +Features.marking+, +Features.firing+, +Features.gradient+ and
-      # +Features.flux+ methods, and their results are joined into a single
-      # feature set.
-      # 
-      def features arg
-        case arg
-        when Features(), Array then Features().new( arg )
-        else # the real job of the method
-          marking = arg[:marking] || []
-          firing = arg[:firing] || [] # array of tS transitions
-          gradient = arg[:gradient] || [ [], transitions: [] ]
-          flux = arg[:flux] || [] # array of TS transitions
-          delta = arg[:delta] || [ [], transitions: [] ]
-          [ Features().marking( marking ),
-            Features().firing( firing ),
-            Features().gradient( *gradient ),
-            Features().flux( flux ),
-            Features().delta( *delta ) ].reduce :+
-        end
-      end
+    delegate :marking, :firing, :gradient, :flux, :delta, to: "Features()"
+  end
 
-      delegate :marking, :firing, :gradient, :flux, :delta, to: "Features()"
-    end
+  # For non-parametrized vesion of the class, the class instance variables
+  # hold the non-parametrized dependent classes.
+  # 
+  @Feature, @Features = Feature, Features
 
-    # For non-parametrized vesion of the class, the class instance variables
-    # hold the non-parametrized dependent classes.
-    # 
-    @Feature, @Features = Feature, Features
+  delegate :net,
+           :Feature,
+           :Features,
+           :features,
+           :marking, :firing, :gradient, :flux, :delta,
+           to: "self.class"
 
-    delegate :net,
-             :Feature,
-             :Features,
-             :features,
-             :marking, :firing, :gradient, :flux, :delta,
-             to: "self.class"
+  # Given a set of clamped places,  this method outputs a Record instance
+  # containing the marking of the free places (complementary to the supplied
+  # set of clamped places). I no set of clamped places is supplied, it is
+  # considered empty.
+  # 
+  def to_record clamped_places=[]
+    free_places = case clamped_places
+                  when Hash then to_record( clamped_places.keys )
+                  else
+                    free_places = places - places( clamped_places )
+                  end
+    features( marking: free_places ).Record.load markings( free_places ) 
+  end
 
-    # Reconstructs a simulation from the current state instance, given marking
-    # clamps and other simulation settings.
-    # 
-    def reconstruct marking_clamps: {}, **settings
-      net.simulation marking: to_hash,
-                     marking_clamps: marking_clamps,
-                     **settings
-    end
-  end # class State
-end # YPetri::Net
+  # Marking of a single given place in this state.
+  # 
+  def marking place_id
+    self[ places.index place( place_id ) ]
+  end
+
+  # Returns an array of markings of particular places in this state..
+  # 
+  def markings place_ids=nil
+    return markings( places ) if place_ids.nil?
+    place_ids.map &:marking
+  end
+end # YPetri::Net::State

data/lib/y_petri/net/visualization.rb

@@ -2,7 +2,7 @@
 
 # Own visualization capabilities of a Petri net.
 # 
-class YPetri::Net
+module YPetri::Net::Visualization
   # Visualizes the net with Graphviz.
   # 
   def visualize
@@ -51,6 +51,7 @@ class YPetri::Net
       end
     }
     # Generate output image.
+    puts File.expand_path "~/y_petri_graph.png"
     γ.output png: File.expand_path( "~/y_petri_graph.png" )
     # require 'y_support/kde'
     YSupport::KDE.show_file_with_kioclient File.expand_path( "~/y_petri_graph.png" )
@@ -64,4 +65,4 @@ class YPetri::Net
     system "sleep 0.2; kioclient exec 'file:%s'" %
       File.expand_path( '.', file_name )
   end
-end # class YPetri::Net
+end # module YPetri::Net::Visualization

data/lib/y_petri/net.rb

@@ -1,7 +1,9 @@
 #encoding: utf-8
 
-require_relative 'net/visualization'
 require_relative 'net/element_access'
+require_relative 'net/visualization'
+require_relative 'net/own_state'
+require_relative 'net/data_set'
 require_relative 'net/state'
 
 # Represents a _Petri net_: A collection of places and transitions. The
@@ -11,12 +13,13 @@ require_relative 'net/state'
 # neighbors of elements (places or transitions).
 # 
 class YPetri::Net
-  include NameMagic
-  include YPetri::World::Dependency # it is important for the Dependency
-  include ElementAccess             # to be below ElementAccess
+  ★ NameMagic                        # ★ means include
+  ★ ElementAccess                    # to be below ElementAccess
+  ★ Visualization
+  ★ OwnState
 
   class << self
-    include YPetri::World::Dependency
+    ★ YPetri::World::Dependency
 
     # Constructs a net containing a particular set of elements.
     # 
@@ -26,6 +29,7 @@ class YPetri::Net
   end
 
   delegate :world, to: "self.class"
+  delegate :Place, :Transition, :Net, to: :world
 
   # Takes 2 arguments (+:places+ and +:transitions+) and builds a net from them.
   # 
@@ -54,6 +58,8 @@ class YPetri::Net
   def include_transition id
     tr = Transition().instance( id )
     return false if includes_transition? tr
+    msg = "Transition #{tr} has arcs to places outside #{self}!"
+    fail msg unless tr.arcs.all? { |p| includes_place? p }
     true.tap { @transitions << tr }
   end
 
@@ -79,32 +85,31 @@ class YPetri::Net
   # Includes an element in the net.
   # 
   def << element_id
-    element_type, element = begin
-                              [ :place,
-                                self.class.place( element_id ) ]
-                            rescue NameError, TypeError
-                              begin
-                                [ :transition,
-                                  self.class.transition( element_id ) ]
-                              rescue NameError, TypeError => err
-                                msg = "Current world contains no place or" +
-                                  "transition identified by #{element_id}!"
-                                raise TypeError, "#{msg} (#{err})"
-                              end
-                            end
-    case element_type
-    when :place then include_place( element )
-    when :transition then include_transition( element )
-    else fail "Mangled method YPetri::Net#<<!" end
+    begin
+      element = self.class.place( element_id )
+      type = :place
+    rescue NameError, TypeError
+      begin
+        element = self.class.transition( element_id )
+        type = :transition
+      rescue NameError, TypeError => err
+        raise TypeError, "Current world contains no place or transition " +
+          "identified by #{element_id}! (#{err})"
+      end
+    end
+    # Separated to minimize the code inside rescue clause:
+    if type == :place then include_place element
+    elsif type == :transition then include_transition element
+    else fail "Implementation error in YPetri::Net#<<!" end
   end
 
   # Is the net _functional_?
   # 
   def functional?
-    transitions.all? { |t| t.functional? }
+    transitions.any? { |t| t.functional? }
   end
 
-  # Is the net <em>timed</em>?
+  # Is the net _timed_?
   # 
   def timed?
     transitions.any? { |t| t.timed? }

data/lib/y_petri/place/arcs.rb

@@ -1,8 +1,8 @@
-# -*- coding: utf-8 -*-
+# encoding: utf-8
 
 # Connectivity aspect of a Petri net place.
 # 
-class YPetri::Place
+module YPetri::Place::Arcs
   # Transitions that can directly add/remove tokens from this place. Aliased as
   # +#upstream_transitions+ and +#ϝ+. (Digamma resembles "f", meaning function,
   # well known from existing spreadsheet software.)
@@ -93,4 +93,4 @@ class YPetri::Place
   def register_downstream_transition( transition )
     @downstream_arcs << transition
   end
-end # class YPetri::Place
+end # class YPetri::Place::Arcs

data/lib/y_petri/place/guard.rb

@@ -1,132 +1,50 @@
-# -*- coding: utf-8 -*-
+# encoding: utf-8
 
-# Guard mechanics aspect of a place.
+# Marking guard of a place.
 # 
-class YPetri::Place
-  # Marking guard.
-  # 
-  class Guard
-    ERRMSG = -> m, of, assert do
-      "Marking #{m}:#{m.class}" +
-        if of then " of #{of.name || of rescue of}" else '' end +
-        " #{assert}!"
-    end
-
-    attr_reader :place, :assertion, :block
-
-    # Requires a NL guard assertion (used in GuardError messages), and a guard
-    # block expressing the same assertion formally, in code.  Attention: *Only
-    # _false_ result is considered a failure! If the block returns _nil_, the
-    # guard has passed!* When +YPetri::Guard+ is in action (typically via its
-    # +#validate+ method), it raises +YPetri::GuardError+ if the guard block
-    # returns _false_. However, the guard block is welcome to raise +GuardError+
-    # on its own, and for this purpose, it is evaluated inside a special "Lab"
-    # object, with +#fail+ method redefined so as to accept no arguments, and
-    # automatically raise appropriately worded +GuardError+. See also:
-    # {+YPetri#guard+ method}[rdoc-ref:YPetri::guard].
-    # 
-    def initialize( assertion_NL_string, place: nil, &block )
-      @place, @assertion, @block = place, assertion_NL_string, block
-      @Lab = Class.new BasicObject do
-        def initialize λ; @λ = λ end
-        def fail; @λ.call end
-      end
-    end
-
-    # Validates a supplied marking value against the guard block. Raises
-    # +YPetri::GuardError+ if the guard fails, otherwise returns _true_.
-    # 
-    def validate( marking )
-      λ = __fail__( marking, assertion )
-      λ.call if @Lab.new( λ ).instance_exec( marking, &block ) == false
-      return true
-    end
-
-    private
-
-    # Constructs the fail closure.
-    # 
-    def __fail__ marking, assertion
-      pl = place
-      -> { fail YPetri::GuardError, ERRMSG.( marking, pl, assertion ) }
-    end
+class YPetri::Place::Guard
+  ERRMSG = -> m, of, assert do
+    "Marking #{m}:#{m.class}" +
+      if of then " of #{of.name || of rescue of}" else '' end +
+      " #{assert}!"
   end
 
-  # Expects a guard assertion in natural language, and a guard block. Guard
-  # block is a unary block capable of validating a marking value. The validation
-  # is considered as having failed if:
-  #
-  # 1. The block returns _false_.
-  # 2. The block raises +YPetri::GuardError+.
-  #
-  # In all other cases, including the block returning _nil_, the validation is
-  # considered as having passed! The block is evaluated in the context of a
-  # special "Lab" object, which has +#fail+ method redefined so that it can
-  # (and must) be called without parameters, and produces an appropriately
-  # worded +GuardError+. (Other exceptions can be still raised using +#raise+
-  # method.)
+  attr_reader :place, :assertion, :block
+
+  # Requires a NL guard assertion (used in GuardError messages), and a guard
+  # block expressing the same assertion formally, in code.  Attention: *Only
+  # _false_ result is considered a failure! If the block returns _nil_, the
+  # guard has passed!* When +YPetri::Guard+ is in action (typically via its
+  # +#validate+ method), it raises +YPetri::GuardError+ if the guard block
+  # returns _false_. However, the guard block is welcome to raise +GuardError+
+  # on its own, and for this purpose, it is evaluated inside a special "Lab"
+  # object, with +#fail+ method redefined so as to accept no arguments, and
+  # automatically raise appropriately worded +GuardError+. See also:
+  # {+YPetri#guard+ method}[rdoc-ref:YPetri::guard].
   # 
-  # As for the NL assertion, apart from self-documenting the code, it is used
-  # for constructing appropriately worded +GuardError+ messages:
-  #
-  #   guard "should be a number" do |m| fail unless m.is_a? Numeric end
-  #
-  # Then +guard! :foobar+ raises +GuardError+ with message "Marking foobar:Symbol
-  # should be a number!"
-  #
-  # The method returns the reference to the +YPetri::Guard+ object, that has
-  # been constructed and already included in the collection of this place's
-  # guards.
-  #
-  # Finally, this method is overloaded in such way, that if no block is
-  # given to it, it acts as a frontend for the +#federated_guard_closure+
-  # method: It either applies the federated closure to the marking value given
-  # in the argument, or returns the federated closure itself if no arguemnts
-  # were given (behaving as +#federated_guard_closure+ alias in this case).
-  # 
-  def guard *args, &block
-    if block then @guards << Guard.new( *args, place: name || self, &block )
-    elsif args.size == 1 then federated_guard_closure.( args[0] )
-    elsif args.empty? then federated_guard_closure
+  def initialize( assertion_NL_string, place: nil, &block )
+    @place, @assertion, @block = place, assertion_NL_string, block
+    @Lab = Class.new BasicObject do
+      def initialize λ; @λ = λ end
+      def fail; @λ.call end
     end
   end
 
-  # Returns a joint guard closure, composed of all the guards defined for the
-  # place at the moment. Joint closure passes if and only if all the guard
-  # blocks pass for the given marking value.
+  # Validates a supplied marking value against the guard block. Raises
+  # +YPetri::GuardError+ if the guard fails, otherwise returns _true_.
   # 
-  def federated_guard_closure
-    place_name, lineup = name.to_s, guards.dup
-    -> m { lineup.each { |g| g.validate( m ) }; return m }
-  end
-
-  # Applies guards on the marking currently owned by the place.
-  # 
-  def guard!
-    guard.( marking )
+  def validate( marking )
+    λ = __fail__( marking, assertion )
+    λ.call if @Lab.new( λ ).instance_exec( marking, &block ) == false
+    return true
   end
 
   private
 
-  # If no guards were specified by the user, this method can make them up in a
-  # standard way, using user-supplied marking / default marking as a type
-  # reference. Numeric types are an exception – they are considered mutually
-  # interchangeable, except complex numbers.
+  # Constructs the fail closure.
   # 
-  def add_default_guards!( reference_marking )
-    case reference_marking
-    when Complex then marking "should be Numeric" do |m| m.is_a? Numeric end
-    when Numeric then
-      marking "should be Numeric" do |m| m.is_a? Numeric end
-      marking "should not be complex" do |m| fail if m.is_a? Complex end
-      marking "should not be negative" do |m| m >= 0 end
-    when nil then # no guards
-    when true, false then marking "should be Boolean" do |m| m == !!m end
-    else
-      reference_marking.class.tap do |klass|
-        marking "should be a #{klass}" do |m| m.is_a? klass end
-      end
-    end
-    return nil
+  def __fail__ marking, assertion
+    pl = place
+    -> { fail YPetri::GuardError, ERRMSG.( marking, pl, assertion ) }
   end
-end # class YPetri::Place
+end

data/lib/y_petri/place/guarded.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+
+# A mixin to make a place support guards.
+# 
+module YPetri::Place::Guarded
+  # Expects a guard assertion in natural language, and a guard block. Guard
+  # block is a unary block capable of validating a marking value. The validation
+  # is considered as having failed if:
+  #
+  # 1. The block returns _false_.
+  # 2. The block raises +YPetri::GuardError+.
+  #
+  # In all other cases, including the block returning _nil_, the validation is
+  # considered as having passed! The block is evaluated in the context of a
+  # special "Lab" object, which has +#fail+ method redefined so that it can
+  # (and must) be called without parameters, and produces an appropriately
+  # worded +GuardError+. (Other exceptions can be still raised using +#raise+
+  # method.)
+  # 
+  # As for the NL assertion, apart from self-documenting the code, it is used
+  # for constructing appropriately worded +GuardError+ messages:
+  #
+  #   guard "should be a number" do |m| fail unless m.is_a? Numeric end
+  #
+  # Then +guard! :foobar+ raises +GuardError+ with message "Marking foobar:Symbol
+  # should be a number!"
+  #
+  # The method returns the reference to the +YPetri::Guard+ object, that has
+  # been constructed and already included in the collection of this place's
+  # guards.
+  #
+  # Finally, this method is overloaded in such way, that if no block is
+  # given to it, it acts as a frontend for the +#federated_guard_closure+
+  # method: It either applies the federated closure to the marking value given
+  # in the argument, or returns the federated closure itself if no arguemnts
+  # were given (behaving as +#federated_guard_closure+ alias in this case).
+  # 
+  def guard *args, &block
+    if block then
+      @guards << YPetri::Place::Guard.new( *args, place: name || self, &block )
+    elsif args.size == 1 then
+      federated_guard_closure.( args[0] )
+    elsif args.empty? then
+      federated_guard_closure
+    end
+  end
+
+  # Returns a joint guard closure, composed of all the guards defined for the
+  # place at the moment. Joint closure passes if and only if all the guard
+  # blocks pass for the given marking value.
+  # 
+  def federated_guard_closure
+    place_name, lineup = name.to_s, guards.dup
+    -> m { lineup.each { |g| g.validate( m ) }; return m }
+  end
+
+  # Applies guards on the marking currently owned by the place.
+  # 
+  def guard!
+    guard.( marking )
+  end
+
+  private
+
+  # If no guards were specified by the user, this method can make them up in a
+  # standard way, using user-supplied marking / default marking as a type
+  # reference. Numeric types are an exception – they are considered mutually
+  # interchangeable, except complex numbers.
+  # 
+  def add_default_guards!( reference_marking )
+    case reference_marking
+    when Complex then marking "should be Numeric" do |m| m.is_a? Numeric end
+    when Numeric then
+      marking "should be Numeric" do |m| m.is_a? Numeric end
+      marking "should not be complex" do |m| fail if m.is_a? Complex end
+      marking "should not be negative" do |m| m >= 0 end
+    when nil then # no guards
+    when true, false then marking "should be Boolean" do |m| m == !!m end
+    else
+      reference_marking.class.tap do |klass|
+        marking "should be a #{klass}" do |m| m.is_a? klass end
+      end
+    end
+    return nil
+  end
+end # module YPetri::Place::Guarded

data/lib/y_petri/place.rb

@@ -1,16 +1,19 @@
 # encoding: utf-8
 
 require_relative 'place/guard'
+require_relative 'place/guarded'
 require_relative 'place/arcs'
 
 # Represents a Petri net place.
 # 
 class YPetri::Place
-  include NameMagic
-  include YPetri::World::Dependency
+  ★ NameMagic                        # ★ means include
+  ★ Arcs
+  ★ Guarded
+  ★ YPetri::World::Dependency
 
   class << self
-    include YPetri::World::Dependency
+    ★ YPetri::World::Dependency
   end
 
   delegate :world, to: "self.class"

data/lib/y_petri/simulation/element_representation.rb

@@ -4,8 +4,8 @@
 #
 class YPetri::Simulation
   class ElementRepresentation
-    include NameMagic
-    include Dependency
+    ★ NameMagic
+    ★ Dependency
 
     attr_reader :source # source place