y_petri 2.2.4 → 2.3.2

data/lib/y_petri/place.rb

@@ -3,14 +3,16 @@
 require_relative 'place/guard'
 require_relative 'place/guarded'
 require_relative 'place/arcs'
+require_relative 'place/features'
 
 # Represents a Petri net place.
 # 
 class YPetri::Place
   ★ NameMagic                        # ★ means include
+  ★ YPetri::World::Dependency
   ★ Arcs
   ★ Guarded
-  ★ YPetri::World::Dependency
+  ★ Features
 
   class << self
     ★ YPetri::World::Dependency
@@ -21,7 +23,19 @@ class YPetri::Place
 
   attr_reader :quantum
   attr_reader :guards
-  attr_accessor :default_marking
+  attr_reader :has_default_marking
+  alias has_default_marking? has_default_marking
+ 
+  def default_marking
+    fail TypeError, "No default marking was specified for #{self}!" unless
+      has_default_marking?
+    @default_marking
+  end
+
+  def default_marking= marking
+    @has_default_marking = true
+    @default_marking = marking
+  end
 
   # Arguments supplied upon place initialization may include:
   # 
@@ -48,14 +62,19 @@ class YPetri::Place
   # that the place has no guards whatsoever, +:guard+ argumend should be set to
   # _false_.
   # 
-  def initialize quantum: 1,
-                 default_marking: nil,
-                 marking: nil,
-                 guard: L!,
-                 &block
+  def initialize guard: L!, **named_args, &block
     @upstream_arcs, @downstream_arcs, @guards = [], [], [] # init to empty
-    @quantum, @default_marking = quantum, default_marking
-    self.marking = marking || default_marking
+    @quantum = named_args.has?( :quantum ) ? named_args[:quantum] : 1
+    named_args.may_have :default_marking, syn!: :m!
+    if named_args.has? :default_marking then
+      @has_default_marking = true
+      @default_marking = named_args[:default_marking]
+    else
+      @has_default_marking = false
+    end
+    if named_args.has? :marking then @marking = named_args[:marking] else
+      @marking = default_marking if has_default_marking?
+    end
     # Check in :guard value and the corresponding &block.
     if guard.ℓ? then # guard NL assertion not given, use block or default guards
       block ? guard( &block ) : add_default_guards!( @marking )
@@ -67,13 +86,6 @@ class YPetri::Place
     end
   end
 
-  # Getter of the place's +@marking+ attribute.
-  # 
-  def m
-    @marking
-  end
-  alias value m
-
   # Used without arguments, it is a getter of the place's +@marking+ attribute,
   # just like the +Place#m+ method. However, if a string and a block is supplied
   # to it, it acts as an alias of the +Place#guard+ method. This is because this:
@@ -92,6 +104,19 @@ class YPetri::Place
     guard args[0], &block
   end
 
+  # Near-alias for #marking.
+  # 
+  def value
+    marking
+  end
+
+  # Getter of the place's marking attribute under a simulation (current
+  # simulation by default).
+  # 
+  def m simulation=world.simulation
+    simulation.net.State.Feature.Marking( self ) % simulation
+  end
+
   # Marking setter.
   # 
   def marking=( new_marking )
@@ -129,28 +154,36 @@ class YPetri::Place
     @marking = guard.( @default_marking )
   end
 
-  # Builds an inspect string of the place.
+  # Convenience visualizer of the upstream net.
   # 
-  def inspect
-    n, m, d, q = instance_description_strings
-    "#<Place: #{ ( [n, m, d, q].compact ).join ', ' }>"
+  def uv
+    upstream_net.visualize
   end
 
-  # Returns a string representing the place.
-  # 
-  def to_s
-    n, m = name, marking
-    "#{n.nil? ? 'Place' : n}[#{m.nil? ? 'nil' : m}]"
-  end
+  # Let's try leave these to NameMagic
+
+  # # Builds an inspect string of the place.
+  # # 
+  # def inspect
+  #   n, m, d, q = instance_description_strings
+  #   "#<Place: #{ ( [n, m, d, q].compact ).join ', ' }>"
+  # end
+
+  # # Returns a string representing the place.
+  # # 
+  # def to_s
+  #   n, m = name, marking
+  #   "#{n.nil? ? 'Place' : n}[#{m.nil? ? 'nil' : m}]"
+  # end
 
   private
 
   def instance_description_strings
-    m, n, d, q = marking, name, default_marking, quantum
-    nς = "name: #{n.nil? ? '∅' : n}"
+    m, n, q = marking, name, quantum
     mς = "marking: #{m.nil? ? 'nil' : m}"
-    dς = "default_marking: #{d.nil? ? '∅' : d}"
+    nς = "name: #{n.nil? ? '∅' : n}"
     qς = q == 1 ? nil : "quantum: #{q.nil? ? '∅' : q}"
+    dς = "default_marking: #{has_default_marking ? default_marking : '∅'}"
     return nς, mς, dς, qς
   end
 end # class YPetri::Place

data/lib/y_petri/simulation/dependency.rb

@@ -1,8 +1,8 @@
 # encoding: utf-8
 
 # Place / transition collection mixin for parametrized classes of
-# YPetri::Simulation. Expects the module where it is included to define
-# +#simulation+ method returning the current simulation instance.
+# YPetri::Simulation. Expects the includer to provide +#simulation+
+# method returning current +Simulation+ instance.
 #
 class YPetri::Simulation
   module Dependency
@@ -36,72 +36,36 @@ class YPetri::Simulation
       end
     end
 
-    def element *args, &block
-      simulation.send :element, *args, &block
-    end
-
-    def place *args, &block
-      simulation.send :place, *args, &block
-    end
-
-    def transition *args, &block
-      simulation.send :transition, *args, &block
-    end
-
-    def elements *args, &block
-      simulation.send :elements, *args, &block
-    end
-
-    def places *args, &block
-      simulation.send :places, *args, &block
-    end
-
-    def transitions *args, &block
-      simulation.send :transitions, *args, &block
-    end
-
-    def free_places *args, &block
-      simulation.send :free_places, *args, &block
-    end
-
-    def clamped_places *args, &block
-      simulation.send :clamped_places, *args, &block
-    end
-
-    def ts_transitions *args, &block
-      simulation.send :ts_transitions, *args, &block
-    end
-
-    def tS_transitions *args, &block
-      simulation.send :tS_transitions, *args, &block
-    end
-
-    def Ts_transitions *args, &block
-      simulation.send :Ts_transitions, *args, &block
-    end
-
-    def TS_transitions *args, &block
-      simulation.send :TS_transitions, *args, &block
-    end
-
-    def t_transitions *args, &block
-      simulation.send :t_transitions, *args, &block
-    end
-
-    def T_transitions *args, &block
-      simulation.send :T_transitions, *args, &block
-    end
-
-    def s_transitions *args, &block
-      simulation.send :s_transitions, *args, &block
-    end
+    # Necessary to overcoming the protected character of the listed methods.
+    # 
+    [ :node,
+      :place,
+      :transition
+    ].each { |sym| define_method sym do |e| simulation.send sym, e end }
 
-    def S_transitions *args, &block
-      simulation.send :S_transitions, *args, &block
-    end
+    # Necessary to overcoming the protected character of the listed methods.
+    # 
+    [ :Nodes,
+      :Places,
+      :Transitions
+    ].each { |sym| define_method sym do |array| simulation.send sym, array end }
 
-    def A_transitions *args, &block
-      simulation.send :A_transitions, *args, &block
-    end
+    # Necessary to overcoming the protected character of the listed methods.
+    # 
+    [ :nodes,
+      :places,
+      :free_places,
+      :clamped_places,
+      :transitions,
+      :ts_transitions,
+      :tS_transitions,
+      :Ts_transitions,
+      :TS_transitions,
+      :t_transitions,
+      :T_transitions,
+      :s_transitions,
+      :S_transitions,
+      :A_transitions
+    ].each { |sym| define_method sym do |*e| simulation.send sym, *e end }
   end # class Dependency
 end # class YPetri::Simulation

data/lib/y_petri/simulation/feature_set.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-# Basic elements of a simulation, a mixin intended for YPetri::Simulation.
+# Basic nodes of a simulation, a mixin intended for YPetri::Simulation.
 #
 class YPetri::Simulation
   # Represents a set of features of a simulation state.

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

@@ -1,34 +1,51 @@
-#encoding: utf-8
+# encoding: utf-8
 
 # Simulation mixin providing access to the initial marking.
 #
 class YPetri::Simulation::InitialMarking
   module Access
-    # Without arguments, acts as a getter of @initial_marking. If arguments are
-    # supplied, they must identify free places, and are mapped to their initial
-    # marking.
-    # 
-    def initial_marking ids=nil
-      if ids.nil? then
-        @initial_marking or
-          fail TypeError, "InitialMarking object not instantiated yet!"
-      else
-        free_places( ids ).map { |pl| initial_marking[ place( pl ) ] }
-      end
-    end
-
-    # Without arguments, returns the marking of all the simulation's places
-    # (both free and clamped) as it appears after reset. If arguments are
-    # supplied, they must identify places, and are converted to either their
-    # initial marking (free places), or their clamp value (clamped places).
-    # 
-    def im ids=nil
-      return im( places ) if ids.nil?
-      places( ids ).map { |pl|
-        pl.free? ? initial_marking( of: pl ) : marking_clamp( of: pl )
+    # Expects a single array of free places or place ids, and returns an array
+    # of their initial markings.
+    # 
+    def Initial_markings array
+      Free_places( array ).map { |place| initial_marking[ place place ] }
+    end
+    alias initial_Markings Initial_markings
+
+    # Expects an arbitrary number of arguments identifying free places, whose
+    # initial markings are then returned. If no arguments are given, acts as
+    # a getter of +@initial_marking+ instance variable.
+    # 
+    def initial_markings *free_places
+      return initial_marking if free_places.empty?
+      Initial_markings( free_places )
+    end
+
+    # Expects a single free place and returns the value of its initial marking.
+    # 
+    def initial_marking arg=L!
+      return initial_markings( arg ).first unless arg.local_object?
+      @initial_marking or fail TypeError, "+@initial_marking+ not present yet!"
+    end
+
+    # Expects a single array of places, and returns their marking as it would
+    # appear right after the simulation reset.
+    # 
+    def Im array
+      places( array ).map { |place|
+        place.free? ? initial_marking( place ) : marking_clamp( place )
       }
     end
 
+    # Expects an arbitrary number of places or place identifiers, and returns
+    # their marking as it would appear right after the simulation reset. If no
+    # arguments are given, returns all of them.
+    # 
+    def im *places
+      return Im places() if places.empty?
+      Im( places )
+    end
+
     # Returns initial marking vector for free places. Like +#initial_marking+,
     # but returns a column vector.
     # 
@@ -47,9 +64,8 @@ class YPetri::Simulation::InitialMarking
 
     # Sets the initial marking of a place (frontend of +InitialMarking#set+).
     # 
-    def set_initial_marking( of: (fail ArgumentError), to: (fail ArgumentError) )
-      initial_marking.set( of, to: to )
+    def set_initial_marking( place, to: (fail ArgumentError) )
+      initial_marking.set( place, to: to )
     end
   end # module Access
 end # class YPetri::Simulation::InitialMarking
-

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

@@ -1,34 +1,39 @@
-#encoding: utf-8
+# encoding: utf-8
 
 # Simulation mixin providing access to the marking clamps.
 #
 class YPetri::Simulation::MarkingClamps
   module Access
-    # Without arguments, acts as a getter of the @marking_clamp hash. If
-    # arguments are supplied, they must identify clamped places, and are mapped
-    # to their clamp values.
+    # Expects a single array of clamped places or place ids, and returns an array
+    # of their clamp values.
     # 
-    def marking_clamps ids=nil
-      if ids.nil? then
-        @marking_clamps or
-          fail TypeError, "MarkingClamps object not instantiated yet!"
-      else
-        clamped_places( ids ).map { |p| marking_clamp of: p }
-      end
+    def Marking_clamps array
+      Clamped_places( array ).map { |place| marking_clamps.fetch( place ) }
+    end
+    alias marking_Clamps Marking_clamps
+
+    # Expects an arbitrary number of arguments identifying clamped places, whose
+    # marking clamps are then returned. If no arguments are given, acts as a
+    # getter of +@marking_clamps+ instance variable.
+    # 
+    def marking_clamps *clamped_places
+      return Marking_clamps( clamped_places ) unless clamped_places.empty?
+      @marking_clamps or
+        fail TypeError, "+@marking_clamps+ not instantiated yet!"
     end
     alias clamps marking_clamps
 
-    # Marking clamp identification.
+    # Identification of a single marking clamp. Expects a single clamped place or
+    # place id and returns the value of its clamp.
     # 
-    def marking_clamp( of: (fail ArgumentError) )
-      marking_clamps.clamp_of( of )
+    def marking_clamp( clamped_place )
+      marking_clamps( clamped_place ).first
     end
 
     # Sets the marking clamp of a place (frontend of +InitialMarking#set+).
     # 
-    def set_marking_clamp( of: (fail ArgumentError), to: (fail ArgumentError) )
-      marking_clamps.set( of, to: to )
+    def set_marking_clamp( place, to: (fail ArgumentError) )
+      marking_clamps.set( place, to: to )
     end
   end # module Access
 end # class YPetri::Simulation::MarkingClamps
-

data/lib/y_petri/simulation/marking_clamps.rb

@@ -2,8 +2,6 @@
 #
 class YPetri::Simulation
   class MarkingClamps < PlaceMapping
-    alias clamp_of of
-
     # Sets the clamp for a given place to a given value.
     # 
     def set place_id, to: (fail ArgumentError, "No :to value!")

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

@@ -1,45 +1,91 @@
-#encoding: utf-8
+# encoding: utf-8
 
-# A mixin.
+# A mixin to +YPetri::Simulation+.
 # 
 class YPetri::Simulation::MarkingVector
   module Access
-    # Marking of all places (as a column vector).
+    # Marking of the selected places as a column vector. Expects a single array
+    # argument.
     # 
-    def m_vector ids=nil
-      if ids.nil? then
-        @m_vector or fail TypeError, "Marking vector not established yet!"
-      else
-        m_vector.select( ids )
-      end
+    def M_vector array
+      m_vector.select( array )
     end
+    alias m_Vector M_vector
 
-    # Marking of all places (as array).
+    # Acts as a getter of the simulation's state vector, instance variable
+    # +@m_vector+.
     # 
-    def m ids=nil
-      m_vector( ids ).to_a
+    def state
+      @m_vector or fail TypeError, "State not constructed yet!"
     end
 
-    # Marking of all places (as hash).
+    # Convenience method that accepts any number of places or place ids as
+    # arguments, and returns their marking as a column vector. If no arguments
+    # are supplied, the method returns the simulation's state vector.
     # 
-    def place_m ids=nil
-      m_vector( ids ).to_hash
+    def m_vector *places
+      begin
+      return state if places.empty?
+      m_vector.select( places )
+      end
     end
-  
-    # Marking of the indicated places (as hash with place names as keys).
+
+    # Array-returning equivalents of +#M_vector+ and +m_vector+.
+    # 
+    def M *args; M_vector( *args ).to_a end
+    def m *args; m_vector( *args ).to_a end
+
+
+    # map! M: :M_vector,
+    #      m: :m_vector,
+    #      &:column_to_a
+
+    # Hash-returning { place => marking } equivalents Marking of all places
+    # (as hash).
     # 
-    def p_m ids=nil
-      places( ids ).names( true ) >> m( ids )
+    chain Place_m: :M_vector,
+          place_m: :m_vector,
+          &:to_hash
+    alias place_M Place_m
+
+    # Marking of the indicated places as a hash of { place name => marking }
+    # pairs. Expects a single array of places or place ids as an argument.
+    # 
+    def P_m places
+      Places( places ).names( true ) >> M( places )
+    end
+    alias p_M P_m
+    alias Pn_m P_m
+
+    # Marking of the indicated places as a hash of { place name => marking }
+    # pairs. Expects and arbitrary number of places or place ids and arguments.
+    # If no arguments are given, marking of all the places is returned.
+    # 
+    def p_m *places
+      places( *places ).names( true ) >> m( *places )
     end
     alias pn_m p_m
 
-    # Pretty prints marking of the indicated places as hash with place names as
-    # keys. Takes optional list of place ids (ordered argument no. 1), and
-    # optional 2 named arguments (+:gap+ and +:precision+), as in
-    # +#pretty_print_numeric_values+.
+    # Pretty prints marking of the indicated places. Expects an array of places
+    # or place ids as an argument. In addition, accepts 2 optional named
+    # arguments, +:gap+ and +:precision+ (alias +:p+), that control the layout
+    # of the printed table, like in +#pretty_print_numeric_values+ method.
+    # 
+    def Pm places, **named_args
+      gap = named_args[:gap] || 0
+      named_args.may_have :precision, syn!: :pn
+      precision = named_args.delete( :precision ) || 3
+      P_m( places ).pretty_print_numeric_values gap: gap, precision: precision
+    end
+
+    # Pretty prints marking of the indicated places. Expects an arbitrary number
+    # of places or place ids, and 2 optional named arguments, +:gap+ and
+    # +:precision+ (alias +:p+), that control the layout of the printed table,
+    # like in +#pretty_print_numeric_values+ method.
     # 
-    def pm ids=nil, gap: 0, precision: 3
-      p_m( ids ).pretty_print_numeric_values gap: gap, precision: precision
+    def pm *places, **named_args
+      return Pm places() if places.empty?
+      Pm( places, **named_args )
     end
 
     # Modifies the marking vector. Takes one argument. If the argument is a hash
@@ -58,31 +104,44 @@ class YPetri::Simulation::MarkingVector
       else # convert it with #each
         update_m( new_m.each.to_a )
       end
+      return nil
     end
+    alias set_m update_m
 
-    # Marking vector of free places.
+    # Marking vector of free places. Expects an array of places or place ids, for
+    # which the marking vectro is returned.
     # 
-    def marking_vector ids=nil
-      m_vector free_places( ids )
+    def Marking_vector array
+      M_vector Free_places( array )
     end
 
-    # Marking of free places (as array).
+    # Marking vector of free places. Expects an arbitrary number of free places
+    # or place ids and returns the marking vector for them.
     # 
-    def marking ids=nil
-      marking_vector( ids ).to_a
+    def marking_vector *places
+      m_vector *free_places( *places )
     end
 
-    # Marking of free places (as hash).
+    # Array-returning versions of +#Marking_vector+ and +#marking_vector+.
     # 
-    def place_marking ids=nil
-      marking_vector( ids ).to_hash
-    end
+    chain Marking: :Marking_vector,
+          marking: :marking_vector,
+          &:to_a
 
-    # Marking of free places (as hash with place names as keys).
+    # Versions of +#Marking_vector+ and +#marking_vector+ that return hash of
+    # { place => marking } pairs.
     # 
-    def p_marking ids=nil
-      marking_vector( ids ).to_h
-    end
+    chain Place_marking: :Marking_vector,
+          place_marking: :marking_vector,
+          &:to_hash
+
+    # Versions of +#Marking_vector+ and +#marking_vector+ that return hash of
+    # { place name => marking } pairs.
+    # 
+    chain P_marking: :Marking_vector,
+          p_marking: :marking_vector,
+          &:to_h
+    alias Pn_marking P_marking
     alias pn_marking p_marking
 
     # Modifies the marking vector. Like +#update_m+, but the places must be
@@ -92,7 +151,7 @@ class YPetri::Simulation::MarkingVector
     def update_marking new_m
       case new_m
       when Hash then # assume { place => marking } hash
-        ( free_places( *new_m.keys ) >> new_m.values )
+        ( 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!"
@@ -101,13 +160,16 @@ class YPetri::Simulation::MarkingVector
       else # convert it with #each
         update_marking( new_m.each.to_a )
       end
+      return nil
     end
+    alias set_marking update_marking
 
     # 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
+      return nil
     end
   end # module Access
 end # class YPetri::Simulation::MarkingVector