y_petri 2.0.15 → 2.1.3

data/lib/y_petri/simulation/marking_vector/access.rb

@@ -0,0 +1,106 @@
+#encoding: utf-8
+
+# A mixin.
+# 
+class YPetri::Simulation::MarkingVector
+  module Access
+    # Marking of all places (as a column vector).
+    # 
+    def m_vector ids=nil
+      if ids.nil? then
+        msg = "Marking vector not established yet!"
+        @m_vector or fail TypeError, msg
+      else
+        m_vector.select( ids )
+      end
+    end
+
+    # Marking of all places (as array).
+    # 
+    def m ids=nil
+      m_vector( ids ).to_a
+    end
+
+    # Marking of all places (as hash).
+    # 
+    def place_m ids=nil
+      m_vector( ids ).to_hash
+    end
+  
+    # Marking of all places (as hash with place names as keys).
+    # 
+    def p_m ids=nil
+      places( ids ).names( true ) >> m( ids )
+    end
+    alias pn_m p_m
+    alias pm p_m
+
+    # Modifies the marking vector. Takes one argument. If the argument is a hash
+    # of pairs { place => new value }, only the specified places' markings are
+    # updated. If the argument is an array, it must match the number of places
+    # in the simulation, and all marking values are updated.
+    # 
+    def update_m new_m
+      case new_m
+      when Hash then # assume { place => marking } hash
+        new_m.each_pair { |id, val| m_vector.set( id, val ) }
+      when Array then
+        msg = "T be a collection with size == number of net's places!"
+        fail TypeError, msg unless new_m.size == places.size
+        update_m( places >> new_m )
+      else # convert it with #each
+        update_m( new_m.each.to_a )
+      end
+    end
+
+    # Marking vector of free places.
+    # 
+    def marking_vector ids=nil
+      m_vector free_places( ids )
+    end
+
+    # Marking of free places (as array).
+    # 
+    def marking ids=nil
+      marking_vector( ids ).to_a
+    end
+
+    # Marking of free places (as hash).
+    # 
+    def place_marking ids=nil
+      marking_vector( ids ).to_hash
+    end
+
+    # Marking of free places (as hash with place names as keys).
+    # 
+    def p_marking ids=nil
+      marking_vector( ids ).to_h
+    end
+    alias pn_marking p_marking
+
+    # Modifies the marking vector. Like +#update_m+, but the places must be
+    # free places, and if the argument is an array, it must match the number
+    # of free places in the simulation's net.
+    # 
+    def update_marking new_m
+      case new_m
+      when Hash then # assume { place => marking } hash
+        ( free_places( *new_m.keys ) >> new_m.values )
+          .each_pair { |id, val| m_vector.set( id, val ) }
+      when Array then
+        msg = "T be a collection with size == number of net's free places!"
+        fail TypeError, msg unless new_m.size == free_places.size
+        update_m( free_places >> new_m )
+      else # convert it with #each
+        update_marking( new_m.each.to_a )
+      end
+    end
+
+    # Expects a Δ marking vector for free places and performs the specified
+    # change on the marking vector of the simulation.
+    # 
+    def increment_marking Δ_free
+      @m_vector += f2a * Δ_free
+    end
+  end # module Access
+end # class YPetri::Simulation::MarkingVector

data/lib/y_petri/simulation/marking_vector.rb

@@ -0,0 +1,156 @@
+# Basic elements of a simulation, a mixin intended for YPetri::Simulation.
+#
+class YPetri::Simulation
+  class MarkingVector < Matrix
+    include Dependency
+
+    class << self
+      include Dependency
+
+      attr_reader :annotation
+
+      # Constructs a marking vector from a hash places >> values, or from
+      # an array, in which case, it is assumed that the marking vector
+      # corresponds to all the places in the simulation.
+      # 
+      def [] arg
+        case arg
+        when Hash then annotated_with( arg.keys )[ arg.values ]
+        when Array then
+          if annotation then
+            msg = "The size of the argument (#{arg.size}) does not " +
+              "correspond to the annotation size (#{annotation.size})!"
+            fail ArgumentError, msg unless arg.size == annotation.size
+            column_vector arg
+          else
+            annotated_with( places )[ args ]
+          end
+        else
+          self[ args.each.to_a ]
+        end
+      end
+
+      # Returns a subclass of self annotated with the supplied places.
+      # 
+      def annotated_with place_ids
+        annot = if annotation then
+                  annotation.subset place_ids
+                else
+                  places( place_ids )
+                end
+        Class.new self do @annotation = annot end
+      end
+
+      # Without arguments, constructs the starting marking vector for all places,
+      # using either initial values, or clamp values. Optionally, places can be
+      # specified, for which the starting vector is returned.
+      # 
+      def starting place_ids=nil
+        st = -> p { p.free? ? p.initial_marking : p.clamp } # starting value
+        if place_ids.nil? then
+          return starting places if annotation.nil?
+          self[ annotation.map &st ]
+        else
+          annotated_with( place_ids ).starting
+        end
+      end
+
+      # Without arguments, constructs a zero marking vector for all places.
+      # Optionally, places can be specified, for which the zero vector is
+      # returned.
+      # 
+      def zero( place_ids=nil )
+        starting( place_ids ) * 0
+      end
+    end
+
+    delegate :simulation, to: "self.class"
+
+    # Creates a subset of this marking vector.
+    # 
+    def select place_ids, &block
+      if block_given? then
+        msg = "If block is given, arguments are not allowed!"
+        fail ArgumentError, msg unless place_ids.empty?
+        select annotation.select( &block )
+      else
+        pp = places( place_ids )
+        annotated_subcl = self.class.annotated_with( pp )
+        annotated_subcl[ pp.map { |p| fetch p } ]
+      end
+    end
+
+    # Modifying the vector elements.
+    # 
+    def set id, value
+      self[ index( id ), 0 ] = value
+    end
+
+    # Whole vector is reset to a given collection of values. If no argument is
+    # given, starting vector is used.
+    # 
+    def reset! arg=self.class.starting
+      arg.each.to_a.zip( annotation ).map { |value, place| set place, value }
+    end
+
+    # Access of the vector elements.
+    # 
+    def fetch id
+      self[ index( id ), 0  ]
+    end
+
+    # Annotation.
+    # 
+    def annotation
+      self.class.annotation
+    end
+
+    # Index of a place.
+    # 
+    def index id
+      if id.is_a? Numeric then
+        fail RangeError, "Numeric index must be within 0..#{size}" unless
+          ( 0..size ) === id
+      else
+        annotation.index place( id )
+      end
+    end
+
+    # Marking vector size -- depends on the annotation.
+    # 
+    def size
+      annotation.size
+    end
+
+    # Converts the marking vector (which is a column vector) into an array.
+    # 
+    def to_a
+      ( 0..size - 1 ).map { |i| self[ i, 0 ] }
+    end
+
+    # Converts the marking vector into a hash annotation >> values.
+    # 
+    def to_hash
+      annotation >> to_a
+    end
+
+    # Converts the marking vector into a hash annotation_names >> values.
+    # 
+    def to_h
+      annotation.names( true ) >> to_a
+    end
+
+    # Converts the marking vector into a hash source places >> values.
+    # 
+    def to_hash_with_source_places
+      annotation.sources >> to_a
+    end
+
+    # Builds the assignment closure.
+    # 
+    def increment_closure
+      indices_of_free_places = annotation.free.map { |p| annotation.index p }
+      increment_at_indices_closure( indices: indices_of_free_places )
+    end
+  end
+end

data/lib/y_petri/simulation/matrix.rb

@@ -0,0 +1,64 @@
+#encoding: utf-8
+
+require 'matrix'
+
+# Patches the Matrix class with methods that generate code for direct vector
+# access.
+#
+class Matrix
+  class << self
+    # Builds a code string for accessing the vector values at given indices.
+    # 
+    def column_vector_access_code vector: (fail ArgumentError, "No vector!"),
+                                  indices: (fail ArgumentError, "No indices!")
+      indices.map { |i| "#{vector}[#{i}, 0]" }.join( ", " )
+    end
+  
+    # Builds a code string for assigning to a vector at given indices.
+    # 
+    def column_vector_assignment_code vector: (fail ArgumentError, "No vector!"),
+                                      indices: (fail ArgumentError, "No indices!"),
+                                      source: (fail ArgumentError, "No source!")
+      code_lines = indices.map.with_index do |i, source_pos|
+        "#{vector}.send( :[]=, #{i}, 0, #{source}.fetch( #{source_pos} ) )" if i
+      end
+      code_lines.compact.join( "\n" ) << "\n"
+    end
+
+    # Builds a code string for incrementing a vector at given indices. Source is
+    # a vector.
+    # 
+    def column_vector_increment_code vector: (fail ArgumentError, "No vector!"),
+                                     indices: (fail ArgumentError, "No indices!"),
+                                     source: (fail ArgumentError, "No source!")
+      code_lines = indices.map.with_index do |i, source_pos|
+        "#{vector}.send( :[]=, #{i}, 0, %s )" %
+          "#{vector}[#{i}, 0] + #{source}[#{source_pos}, 0]" if i
+      end
+      code_lines.compact.join( "\n" ) << "\n"
+    end
+
+    # Builds a code string for incrementing a vector at given indices. Source is
+    # an array.
+    # 
+    def column_vector_increment_by_array_code vector: (fail ArgumentError, "No vector!"),
+                                              indices: (fail ArgumentError, "No indices!"),
+                                              source: (fail ArgumentError, "No source!")
+      code_lines = indices.map.with_index do |i, source_pos|
+        "#{vector}.send( :[]=, #{i}, 0, %s )" %
+          "#{vector}[#{i}, 0] + #{source}[#{source_pos}]" if i
+      end
+      code_lines.compact.join( "\n" ) << "\n"
+    end
+  end
+
+  # Builds a closure for incrementing a column at given indices.
+  # 
+  def increment_at_indices_closure indices: (fail ArgumentError, "No indices!")
+    v = self
+    eval "-> delta do\n%s\nend" %
+      self.class.column_vector_increment_code( vector: "v",
+                                               indices: indices,
+                                               source: "delta" )
+  end
+end

data/lib/y_petri/simulation/place_mapping.rb

@@ -0,0 +1,62 @@
+# Manages the initial marking of a simulation.
+# 
+class YPetri::Simulation
+  class PlaceMapping < Hash
+    include Dependency
+
+    class << self
+      # Initializes the initial marking from a hash.
+      # 
+      def load hash
+        new.tap do |inst|
+          hash.with_values do |v|
+            v = v.marking if v.is_a? YPetri::Place
+            if v.is_a? Proc then v.call else v end
+          end.tap &inst.method( :load )
+        end
+      end
+    end
+
+    delegate :simulation, to: "self.class"
+
+    alias places keys
+
+    # Returns the initial marking as a column vector.
+    # 
+    def vector
+      simulation.MarkingVector[ self ]
+    end
+    alias to_marking_vector vector
+
+    # Sets the mapping value for a given place to a given value.
+    # 
+    def set place_id, to: (fail ArgumentError, "No :to value!")
+      update place( place_id ) => to
+    end
+
+    # Loads initial the mappings from a hash places >> values.
+    # 
+    def load( hash )
+      hash.each { |place, value| set place, to: value }
+    end
+
+    # Fetches the value for a place.
+    # 
+    def of place_id
+      fetch place( place_id )
+    end
+
+    # Deletes the value for a place.
+    # 
+    def delete place_id
+      super place( place_id )
+    end
+
+    # Returns a hash, whose keys have been replaced with source places of
+    # the place representations in this place mapping.
+    # 
+    def keys_to_source_places
+      with_keys do |key| key.source end
+    end
+  end # class InitialMarking
+end # class YPetri::Simulation

data/lib/y_petri/simulation/place_representation.rb

@@ -0,0 +1,74 @@
+#encoding: utf-8
+
+# Representation of a YPetri::Place inside a YPetri::Simulation instance.
+# 
+class YPetri::Simulation
+  class PlaceRepresentation < ElementRepresentation
+    # Index
+    def m_vector_index
+      places.index( self )
+    end
+
+    # Expect a single YPetri place as an argument.
+    # 
+    def initialize net_place
+      super
+    end
+
+    # Setter of clamp.
+    # 
+    def clamp=( value )
+      simulation.set_marking_clamp( of: self, to: value )
+    end
+
+    # Setter of initial marking.
+    # 
+    def initial_marking=( value )
+      simulation.set_initial_marking( of: self, to: value )
+    end
+
+    # Marking clamp value (or nil, if the place is clamped).
+    # 
+    def marking_clamp
+      simulation.marking_clamp of: self if clamped?
+    end
+    alias clamp marking_clamp
+
+    # Initial marking value (or nil, if the place is free).
+    # 
+    def initial_marking
+      simulation.initial_marking[ self ] if free?
+    end
+
+    # Is the place free in the current simulation?
+    # 
+    def free?
+      simulation.initial_marking.places.include? self
+    end
+
+    # Is the place clamped in the current simulation?
+    # 
+    def clamped?
+      simulation.marking_clamps.places.include? self
+    end
+
+    # Set the marking of this place in the simulation.
+    # 
+    def m=( value )
+      m_vector.set self, value
+    end
+
+    # Alias of #m=
+    # 
+    def marking=( value )
+      m=( value )
+    end
+
+    # Get the current marking of this place in the simulation.
+    # 
+    def m
+      m_vector[ self ]
+    end
+    alias marking m
+  end # class PlaceRepresentation
+end # class YPetri::Simulation

data/lib/y_petri/simulation/places/access.rb

@@ -0,0 +1,121 @@
+#encoding: utf-8
+
+# Simulation mixin providing access to places.
+#
+class YPetri::Simulation::Places
+  module Access
+    # With no arguments, a reader of @f2a -- the correspondence matrix between
+    # free places and all places. If argument is given, it is assumed to be
+    # a column vector, and multiplication is performed.
+    # 
+    def f2a arg=nil
+      if arg.nil? then @f2a else @f2a * arg end
+    end
+
+    # With no arguments, a reader of @c2a -- the correspondence matrix between
+    # clamped places and all places. If argument is given, it is assumed to be
+    # a column vector, and multiplication is performed.
+    # 
+    def c2a arg=nil
+      if arg.nil? then @c2a else @c2a * arg end
+    end
+
+    # Does a place belong to the simulation?
+    # 
+    def includes_place? id
+      true.tap { begin; place id
+                 rescue NameError, TypeError
+                   return false
+                 end }
+    end
+    alias include_place? includes_place?
+
+    # Place of the simulation (belonging to the net).
+    # 
+    def p( id )
+      place( id ).source
+    end
+
+    # Places of the simulation (belonging to the net).
+    # 
+    def pp( ids=nil )
+      places( ids ).sources
+    end
+
+    # Free places of the simulation (belonging to the net).
+    # 
+    def free_pp( ids=nil )
+      free_places( ids ).sources
+    end
+
+    # Clamped places of the simulation (belonging to the net).
+    # 
+    def clamped_pp( ids=nil )
+      clamped_places( ids ).sources
+    end
+
+    # Places' names. Arguments, if any, are treated as in +#places+ method.
+    # 
+    def pn( ids=nil )
+      places( ids ).names
+    end
+
+    # Names of free places. Arguments are handled as with +#free_places+.
+    # 
+    def nfree ids=nil
+      free_places( ids ).names
+    end
+    alias free_pn nfree
+
+    # Names of free places. Arguments are handled as with +#clamped_places+.
+    # 
+    def nclamped ids=nil
+      clamped_places( ids ).names
+    end
+    alias clamped_pn nclamped
+
+    protected
+
+    # Place instance identification.
+    # 
+    def place( id )
+      begin
+        Place().instance( id )
+      rescue NameError, TypeError
+        begin
+          pl = net.place( id )
+          places.find { |p_rep| p_rep.source == pl } ||
+            Place().instance( pl.name )
+        rescue NameError, TypeError => msg
+          raise
+          raise TypeError, "The argument #{id} (class #{id.class}) does not identify a " +
+            "place instance! (#{msg})"
+        end
+      end
+    end
+
+    # Without arguments, returns all the places. If arguments are given, they
+    # are converted to places before being returned.
+    # 
+    def places( ids=nil )
+      return @places if ids.nil?
+      Places().load( ids.map { |id| place id } )
+    end
+
+    # Free places. If arguments are given, they must be identify free places,
+    # and are converted to them.
+    # 
+    def free_places ids=nil
+      return places.free if ids.nil?
+      places.free.subset( ids )
+    end
+
+    # Clamped places. If arguments are given, they must be identify clamped
+    # places, and are converted to them.
+    # 
+    def clamped_places ids=nil
+      return places.clamped if ids.nil?
+      places.clamped.subset( ids )
+    end
+  end # module Access
+end # class YPetri::Simulation::Places

data/lib/y_petri/simulation/places/clamped.rb

@@ -0,0 +1,8 @@
+#encoding: utf-8
+
+# A mixin for collections of free places.
+# 
+class YPetri::Simulation::Places
+  module Type_clamped
+  end # Type_clamped
+end # class YPetri::Simulation::Places

data/lib/y_petri/simulation/places/free.rb

@@ -0,0 +1,8 @@
+#encoding: utf-8
+
+# A mixin for collections of free places.
+# 
+class YPetri::Simulation::Places
+  module Type_free
+  end # Type_free
+end # class YPetri::Simulation::Places

data/lib/y_petri/simulation/places/types.rb

@@ -0,0 +1,25 @@
+#encoding: utf-8
+
+# A mixin with place type selectors.
+# 
+class YPetri::Simulation
+  class Places < Elements
+    module Types
+      # Subset of free places, if any.
+      # 
+      def free
+        ( @Type_free ||= Class.new( self.class ).tap do |klass|
+            klass.class_exec { include Type_free }
+          end ).load subset( &:free? )
+      end
+
+      # Subset of clamped places, if any.
+      # 
+      def clamped
+        ( @Type_clamped ||= Class.new( self.class ).tap do |klass|
+            klass.class_exec { include Type_clamped }
+          end ).load subset( &:clamped? )
+      end
+    end # Types
+  end # class Places
+end # class YPetri::Simulation

data/lib/y_petri/simulation/places.rb

@@ -0,0 +1,41 @@
+#encoding: utf-8
+
+require_relative 'places/types'
+require_relative 'places/free'
+require_relative 'places/clamped'
+
+# Place collection for YPetri::Simulation.
+#
+class YPetri::Simulation::Places
+  include Types
+
+  # Pushes a place to the collection.
+  # 
+  def push place
+    p = begin
+          net.place( place )
+        rescue NameError, TypeError
+          return super place( place )
+        end
+    super p.name ? Place().new( p, name: p.name ) : Place().new( p )
+  end
+
+  # Ensures that all the places that are not clamped have their initial marking
+  # set. Optional argument :use_default_marking is set to _true_ by default, in
+  # which case own default marking of the source places is used if it was not
+  # specified when constructing the simulation. If set to _false_, then presence
+  # of places with missing initial marking simply raises errors.
+  # 
+  def complete_initial_marking( use_default_marking: true )
+    missing = reject { |pl| ( free + clamped ).include? pl }
+    unless use_default_marking
+      fail TypeError, "All places must have default marking or clamp!" unless
+        missing.empty?
+    end
+    missing.each { |pl|
+      dflt = pl.source.default_marking
+      fail TypeError, "Source's default marking is missing (nil)!" if dflt.nil?
+      simulation.send :set_initial_marking, { of: pl, to: dflt }
+    }
+  end
+end # class YPetri::Simulation::Places