y_petri 2.2.4 → 2.3.2

data/lib/y_petri/simulation/marking_vector.rb

@@ -1,8 +1,8 @@
 # encoding: utf-8
 
-# Basic elements of a simulation, a mixin intended for YPetri::Simulation.
-#
 class YPetri::Simulation
+  # The class in which places' marking is stored insid a simulation.
+  #
   class MarkingVector < Matrix
     ★ Dependency
 
@@ -20,10 +20,10 @@ class YPetri::Simulation
         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
+            fail ArgumentError, "The size of the argument (#{arg.size}) does " +
+              "not match the annotation size (#{annotation.size})!" unless
+              msg unless arg.size == annotation.size
+            column_vector( arg )
           else
             annotated_with( places )[ args ]
           end
@@ -32,57 +32,55 @@ class YPetri::Simulation
         end
       end
 
-      # Returns a subclass of self annotated with the supplied places.
+      # Returns a subclass of self annotated with the supplied array of places.
       # 
-      def annotated_with place_ids
-        annot = if annotation then
-                  annotation.subset place_ids
-                else
-                  places( place_ids )
-                end
+      def annotated_with places
+        annot = annotation ? annotation.subset( places ) : Places( places )
         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.
+      # Without arguments, constructs the starting marking vector for all the
+      # places, using either initial values, or clamp values. Optionally, an
+      # array of places or place ids can be supplied, 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 ]
+      def starting places=nil
+        if places.nil? then
+          return starting places() if annotation.nil?
+          self[ annotation.map { |p| p.free? ? p.initial_marking : p.clamp } ]
         else
-          annotated_with( place_ids ).starting
+          annotated_with( places ).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.
+      # Without arguments, constructs a zero marking vector for all the places.
+      # Optionally, an array of places or places ids can be supplied, for which
+      # the zero vector is returned.
       # 
-      def zero( place_ids=nil )
-        starting( place_ids ) * 0
+      def zero places=nil
+        starting( places ) * 0
       end
     end
 
     delegate :simulation, to: "self.class"
 
-    # Creates a subset of this marking vector.
+    # Expects an array of places or place ids, and creates a subset of this
+    # marking vector. Alternatively, a block can be supplied that performs
+    # the places selection similarly to +Enumerable#select+.
     # 
-    def select place_ids, &block
+    def select places, &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 )
+        fail ArgumentError, "Arguments not allowed if block given!" unless
+          place_ids.empty?
+        select annotation.select &block
       else
-        pp = places( place_ids )
+        pp = places( *places )
         annotated_subcl = self.class.annotated_with( pp )
         annotated_subcl[ pp.map { |p| fetch p } ]
       end
     end
 
-    # Modifying the vector elements.
+    # Modifying the vector nodes.
     # 
     def set id, value
       self[ index( id ), 0 ] = value
@@ -104,7 +102,7 @@ class YPetri::Simulation
       end
     end
 
-    # Access of the vector elements.
+    # Access of the vector nodes.
     # 
     def fetch id
       self[ index( id ), 0  ]
@@ -166,8 +164,8 @@ class YPetri::Simulation
 
     # Pretty-prints the marking vector.
     # 
-    def pretty_print
-      to_h.pretty_print_numeric_values
+    def pretty_print *args
+      to_h.pretty_print_numeric_values *args
     end
     alias pp pretty_print
   end

data/lib/y_petri/simulation/matrix.rb

@@ -1,4 +1,4 @@
-#encoding: utf-8
+# encoding: utf-8
 
 require 'matrix'
 

data/lib/y_petri/simulation/node_representation.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+# Representation of a YPetri::Place inside a YPetri::Simulation instance.
+#
+class YPetri::Simulation::NodeRepresentation
+  ★ NameMagic
+  ★ YPetri::Simulation::Dependency
+
+  attr_reader :source # source place
+
+  delegate :simulation, to: "self.class"
+
+  # Expect a single YPetri place as an argument.
+  # 
+  def initialize net_node_id
+    @source = net.node( net_node_id )
+  end
+
+  # Tweak the #to_s method to give the node representations the inspect string
+  # of type #<Name>.
+  # 
+  def to_s
+    "#<#{super}>"
+  end
+end # class YPetri::Simulation::NodeRepresentation

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

@@ -0,0 +1,78 @@
+# encoding: utf-8
+
+# Simulation mixin providing access to nodes (places / transitions). Also see
+# mixins +Places::Access+ and +Transitions::Access+.
+# 
+class YPetri::Simulation::Nodes
+  module Access
+    # Does a node belong to the simulation?
+    # 
+    def includes?( id )
+      includes_place?( id ) || includes_transition?( id )
+    end
+    alias include? includes?
+
+    # Node of the simulation belonging to the net. Each simulation has its
+    # representations of places and transitions, which are based on the places
+    # and transitions of the underlying net. This method takes one argument,
+    # which (place, place name, transition, or transition name) and returns the
+    # corresponding node of the underlying net.
+    # 
+    def n( node )
+      node( node ).source
+    end
+
+    # Nodes of the simulation (belonging to the net). Expects a single array of
+    # nodes (places / transitions) or node ids and returns an array of the
+    # corresponding nodes in the underlying net.
+    # 
+    def Nn( array )
+      Nodes( array ).sources
+    end
+
+    # Without arguments, returns all the nodes of the underlying net. Otherwise,
+    # it accepts an arbitrary number of nodes or node ids as arguments, and
+    # returns an array of the corresponding nodes of the underlying net.
+    # 
+    def nn( *nodes )
+      nodes( *nodes ).sources
+    end
+
+    # Names of the simulation's nodes. Arguments, if any, are treated
+    # analogically to the +#nodes+ method.
+    # 
+    def nnn *nodes
+      nnn( *nodes ).names
+    end
+
+    protected
+
+    # Node instance identification.
+    # 
+    def node( node )
+      return place node if include_place? node
+      return transition node if include_transition? node
+      fail TypeError, "No node #{node} in the simulation!"
+    end
+
+    # Expects a single array of nodes (places / transitions) or node ids and
+    # returns an array of the corresponding node instances.
+    # 
+    def Nodes( array )
+      # NOTE: At the moment, the Simulation instance does not have a
+      # parametrized subclass of Simulation::Nodes class, the following
+      # statement is thus made to return a plain array of elements.
+      Nodes().load array.map &method( :node )
+    end
+
+    # Without arguments, returns all the nodes (places / transitions) of the
+    # simulation. Otherwise, it accepts an arbitrary number of nodes or node ids
+    # as arguments, and returns an array of the corresponding nodes of the
+    # simulation.
+    # 
+    def nodes( *nodes )
+      return places + transitions if nodes.empty?
+      Nodes( nodes )
+    end
+  end # module Access
+end # class YPetri::Simulation::Nodes

data/lib/y_petri/simulation/{elements.rb → nodes.rb}

@@ -1,9 +1,9 @@
 # encoding: utf-8
 
-# Basic elements of a simulation, a mixin intended for YPetri::Simulation.
-# 
 class YPetri::Simulation
-  class Elements < Array
+  # An array of simulation owned places and/or transitions.
+  # 
+  class Nodes < Array
     ★ Dependency
 
     class << self
@@ -16,28 +16,29 @@ class YPetri::Simulation
 
     delegate :simulation, to: "self.class"
 
-    # Loads elements to this collection.
+    # Loads nodes to this collection.
     #
-    def load elements
-      elements.each{ |e| push e }
+    def load nodes
+      nodes.each{ |node| push node }
     end
 
     # Creates a subset of this collection (of the same class).
     # 
-    def subset element_ids=nil, &block
+    def subset nodes=nil, &block
       if block_given? then
-        msg = "If block is given, arguments are not allowed!"
-        fail ArgumentError, msg unless element_ids.nil?
+        fail ArgumentError, "If block given, arguments not allowed!" unless
+          nodes.nil?
         self.class.load select( &block )
       else
-        ee = elements( element_ids )
-        ee.all? { |e| include? e } or
+        fail ArgumentError, "A collection or a block expected!" if nodes.nil?
+        nn = Nodes( nodes )
+        nn.all? { |node| include? node } or
           fail TypeError, "All subset elements must be in the collection."
-        self.class.load( ee )
+        self.class.load( nn )
       end
     end
 
-    # Returns an array of the element sources (elemens in the original net).
+    # Returns an array of the node sources (nodes in the underlying net).
     # 
     def sources
       map &:source

data/lib/y_petri/simulation/place_mapping.rb

@@ -44,8 +44,8 @@ class YPetri::Simulation
 
     # Fetches the value for a place.
     # 
-    def of place_id
-      fetch place( place_id )
+    def fetch place_id
+      super place( place_id )
     end
 
     # Deletes the value for a place.

data/lib/y_petri/simulation/place_representation.rb

@@ -3,10 +3,11 @@
 # Representation of a YPetri::Place inside a YPetri::Simulation instance.
 # 
 class YPetri::Simulation
-  class PlaceRepresentation < ElementRepresentation
+  class PlaceRepresentation < NodeRepresentation
     attr_reader :quantum
 
-    # Index
+    # Index.
+    # 
     def m_vector_index
       places.index( self )
     end
@@ -21,32 +22,32 @@ class YPetri::Simulation
     # Setter of clamp.
     # 
     def clamp=( value )
-      simulation.set_marking_clamp( of: self, to: value )
+      simulation.set_marking_clamp( self, to: value )
     end
 
     # Setter of initial marking.
     # 
     def initial_marking=( value )
-      simulation.set_initial_marking( of: self, to: value )
+      simulation.set_initial_marking( self, to: value )
     end
 
     # Marking clamp value (or nil, if the place is clamped).
     # 
     def marking_clamp
-      simulation.marking_clamp of: self if clamped?
+      simulation.marking_clamp( 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?
+      simulation.initial_marking( self ) if free?
     end
 
     # Is the place free in the current simulation?
     # 
     def free?
-      simulation.initial_marking.places.include? self
+      simulation.initial_markings.places.include? self
     end
 
     # Is the place clamped in the current simulation?

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

@@ -1,121 +1,140 @@
-#encoding: utf-8
+# 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.
+    # With no arguments, acts as 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 with f2a is performed.
     # 
     def f2a arg=nil
-      if arg.nil? then @f2a else @f2a * arg end
+      arg.nil? ? @f2a : @f2a * arg
     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.
+    # With no arguments, acts as 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 with c2a is performed.
     # 
     def c2a arg=nil
-      if arg.nil? then @c2a else @c2a * arg end
+      arg.nil? ? @c2a : @c2a * arg
     end
 
     # Does a place belong to the simulation?
     # 
-    def includes_place? id
-      true.tap { begin; place id
-                 rescue NameError, TypeError
+    def includes_place? place
+      true.tap { begin; place place; rescue NameError, TypeError
                    return false
                  end }
     end
     alias include_place? includes_place?
 
-    # Place of the simulation (belonging to the net).
+    # Net's place.
     # 
-    def p( id )
-      place( id ).source
+    def p( place )
+      place( place ).source
     end
 
-    # Places of the simulation (belonging to the net).
+    # Makes it so that when "places" is abbreviated to "pp", places of the
+    # underlying net are returned rather than simulation's place representations.
     # 
-    def pp( ids=nil )
-      places( ids ).sources
-    end
+    chain Pp: :Places,
+          pp: :places,
+          Free_pp: :Free_places,
+          free_pp: :free_places,
+          Clamped_pp: :Clamped_places,
+          clamped_pp: :clamped_places,
+          &:sources
 
-    # Free places of the simulation (belonging to the net).
-    # 
-    def free_pp( ids=nil )
-      free_places( ids ).sources
-    end
+    alias free_Pp Free_pp
+    alias clamped_Pp Clamped_pp
 
-    # Clamped places of the simulation (belonging to the net).
+    # Makes it so that +Pn+/+pn+ means "names of places", and that when message
+    # "n" + place_type is sent to the simulation, it returns names of the places
+    # of the specified type.
     # 
-    def clamped_pp( ids=nil )
-      clamped_places( ids ).sources
-    end
+    chain Pn: :Pt,
+          pn: :pp,
+          nfree: :free_places,
+          nclamped: :clamped_places do |r| r.names( true ) 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
+    def place( place )
+      begin; Place().instance( place ); rescue NameError, TypeError
         begin
-          pl = net.place( id )
-          places.find { |p_rep| p_rep.source == pl } ||
-            Place().instance( pl.name )
+          place = net.place( place )
+          places.find { |place_rep| place_rep.source == place } ||
+            Place().instance( place.name )
         rescue NameError, TypeError => msg
-          raise
-          raise TypeError, "The argument #{id} (class #{id.class}) does not identify a " +
-            "place instance! (#{msg})"
+          raise # FIXME: This raise needs to be here in order for the current
+          # tests to pass (they expect NameError, while the raise below would
+          # raise TypeError). But it is not clear to me anymore why the tests
+          # require NameError in the first place. Gotta look into it.
+          raise TypeError, "The argument #{place} (class #{place.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.
+    # Constructs an instance of @Places parametrized subclass. Expects a single
+    # array of places or place ids and returns an array of corresponding place
+    # representations in the simulation. Note that the includer of the
+    # +Places::Access+ module normally overloads :Places message in such way,
+    # that even without an argument, it does not fail, but returns the @Places
+    # parametrized subclass itself.
+    # 
+    def Places( array )
+      # Kernel.p array
+      Places().load array.map &method( :place )
+    end
+
+    # Without arguments, returns all the place representations in the simulation.
+    # Otherwise, it accepts an arbitrary number of places or place ids as
+    # arguments, and a corresponding array of place representations.
+    # 
+    def places( *places )
+      return @places if places.empty?
+      Places( places )
+    end
+
+    # Expects a single array of free places or place ids and returns an array of
+    # the corresponding free place representations in the simulation.
+    # 
+    def Free_places( array )
+      places.free.subset( array )
+    end
+    alias free_Places Free_places
+
+    # Without arguments, returns all free places of the simulation. Otherwise, it
+    # accepts an arbitrary number of free places or place ids as arguments, and
+    # returns an array of the corresponding free places of the simulation.
     # 
-    def places( ids=nil )
-      return @places if ids.nil?
-      Places().load( ids.map { |id| place id } )
+    def free_places( *free_places )
+      return places.free if free_places.empty?
+      Free_places( free_places )
     end
 
-    # Free places. If arguments are given, they must be identify free places,
-    # and are converted to them.
+    # Expects a single array of clamped places or place ids and returns an array
+    # of the corresponding clamped place representations in the simulation.
     # 
-    def free_places ids=nil
-      return places.free if ids.nil?
-      places.free.subset( ids )
+    def Clamped_places( array )
+      places.clamped.subset( array )
     end
+    alias clamped_Places Clamped_places
 
-    # Clamped places. If arguments are given, they must be identify clamped
-    # places, and are converted to them.
+    # Withoud arguments, returns all clamped places of the simulation. Otherwise,
+    # it accepts an arbitrary number of clamped places or place ids as arguments,
+    # and returns and array of the correspondingg clamped places.
     # 
-    def clamped_places ids=nil
-      return places.clamped if ids.nil?
-      places.clamped.subset( ids )
+    def clamped_places( *clamped_places )
+      return places.clamped if clamped_places.empty?
+      Clamped_places( clamped_places )
     end
   end # module Access
 end # class YPetri::Simulation::Places

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

@@ -1,4 +1,4 @@
-#encoding: utf-8
+# encoding: utf-8
 
 # A mixin for collections of free places.
 # 

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

@@ -1,25 +1,23 @@
-#encoding: utf-8
+# 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
+class YPetri::Simulation::Places
+  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 YPetri::Simulation::Places