y_petri 2.2.4 → 2.3.2

data/lib/y_petri/net/node_access.rb

@@ -0,0 +1,282 @@
+# Access to nodes (places and transitions) of a Petri net.
+# 
+module YPetri::Net::NodeAccess
+  # Does the net include a place?
+  # 
+  def include_place? id
+    begin
+      place( id ) and true
+    rescue NameError, TypeError; false end
+  end
+
+  # Does the net include a transition?
+  # 
+  def include_transition? id
+    begin; transition( id ) and true; rescue NameError, TypeError; false end
+  end
+
+  # Inquirer whether the net includes a node.
+  # 
+  def include? id
+    include_place?( id ) || include_transition?( id )
+  end
+
+  # Returns the net's place identified by the argument.
+  # 
+  def place id
+    ( super rescue Place().instance( id ) ).tap do |p|
+      fail TypeError, "No place #{id} in the net!" unless places.include? p
+    end
+  end
+
+  # Returns the net's transition identified by the argument.
+  # 
+  def transition id
+    ( super rescue Transition().instance( id ) ).tap do |t|
+      transitions.include? t or fail TypeError, "No transition #{id} in the net!"
+    end
+  end
+
+  # Returns the net's node identified by the argument
+  # 
+  def node id
+    begin; place( id ); rescue NameError, TypeError
+      begin; transition( id ); rescue NameError, TypeError
+        puts "Hello from failed #node, id is:"
+        puts id
+        p id
+        raise TypeError, "The net does not include place/transition #{id}!"
+      end
+    end
+  end
+
+  # Expects an array of nodes (places/transitions) or node ids, and returns an
+  # array of corresponding node instances.
+  # 
+  def Nodes array
+    array.map &method( :node )
+  end
+
+  # Expects an arbitrary number of nodes (places/transitions) or node ids and
+  # returns an array of corresponding node instances. If no arguments are
+  # supplied, returns all the nodes.
+  # 
+  def nodes *nodes
+    return @places + @transitions if nodes.empty?
+    Nodes( nodes )
+  end
+  alias nn nodes
+
+  # Expects an array of places or place ids, and returns an array of
+  # corresponding place instances.
+  # 
+  def Places array
+    array.map &method( :place )
+  end
+
+  # Expects an arbitrary number of places or place ids and returns an array of
+  # corresponding place instances. If no arguments are supplied, returns all
+  # net's places.
+  # 
+  def places *places
+    return @places.dup if places.empty?
+    Places( places )
+  end
+  alias pp places
+
+  # Expects an array of transitions or transition ids, and returns an array of
+  # corresponding transition instances.
+  # 
+  def Transitions array
+    array.map &method( :transition )
+  end
+
+  # Expects an arbitrary number of transitions or transition ids and returns
+  # an array of corresponding transition instances. If no arguments are supplied,
+  # returns all net's transitions.
+  # 
+  def transitions *transitions
+    return @transitions.dup if transitions.empty?
+    Transitions( transitions )
+  end
+  alias tt transitions
+
+  # Expects an array of *ts* transitions or transition ids, and returns an array
+  # of corresponding transition instances.
+  # 
+  def ts_Transitions array
+    Transitions( array ).aT_all "transition identifiers", "be ts", &:ts?
+  end
+
+  # Expects an arbitrary number of *ts* transitions or transition ids as
+  # arguments, and returns an array of corresponding transition instances.
+  # 
+  def ts_transitions *transitions
+    return transitions().select &:ts? if transitions.empty?
+    ts_Transitions( transitions )
+  end
+  alias ts_tt ts_transitions
+
+  # Expects an array of *tS* transitions or transition ids, and returns an array
+  # of corresponding transition instances.
+  # 
+  def tS_Transitions array
+    Transitions( array ).aT_all "transition identifiers", "be tS", &:tS?
+  end
+
+  # Expects an arbitrary number of *tS* transitions or transition ids as
+  # arguments, and returns an array of corresponding transition instances.
+  # 
+  def tS_transitions *transitions
+    return transitions().select &:tS? if transitions.empty?
+    tS_Transitions( transitions )
+  end
+  alias tS_tt tS_transitions
+
+  # Expects an array of *Ts* transitions or transition ids, and returns an array
+  # of corresponding transition instances.
+  # 
+  def Ts_Transitions array
+    Transitions( array ).aT_all "transition identifiers", "be Ts", &:Ts?
+  end
+
+  # Expects an arbitrary number of *Ts* transitions or transition ids as
+  # arguments, and returns an array of corresponding transition instances.
+  # 
+  def Ts_transitions *transitions
+    return transitions().select &:Ts? if transitions.empty?
+    Ts_Transitions( transitions )
+  end
+  alias Ts_tt Ts_transitions
+
+  # Expects an array of *TS* transitions or transition ids, and returns an array
+  # of corresponding transition instances.
+  # 
+  def TS_Transitions array
+    Transitions( array ).aT_all "transition identifiers", "be TS", &:TS?
+  end
+
+  # Expects an arbitrary number of *TS* transitions or transition ids as
+  # arguments, and returns an array of corresponding transition instances.
+  # 
+  def TS_transitions *transitions
+    return transitions().select &:TS? if transitions.empty?
+    TS_Transitions( transitions )
+  end
+  alias TS_tt TS_transitions
+
+  # Expects an array of *A* transitions or transition ids, and returns an array
+  # of corresponding transition instances.
+  # 
+  def A_Transitions array
+    Transitions( array ).aT_all "transition identifiers", "be A", &:A?
+  end
+
+  # Expects an arbitrary number of *A* transitions or transition ids as
+  # arguments, and returns an array of corresponding transition instances.
+  # 
+  def A_transitions *transitions
+    return transitions().select &:A? if transitions.empty?
+    A_Transitions( transitions )
+  end
+  alias A_tt A_transitions
+
+  # Expects an array of *a* transitions or transition ids, and returns an array
+  # of corresponding transition instances.
+  # 
+  def a_Transitions array
+    Transitions( array ).aT_all "transition identifiers", "be a", &:a?
+  end
+
+  # Expects an arbitrary number of *a* transitions or transition ids as
+  # arguments, and returns an array of corresponding transition instances.
+  # 
+  def a_transitions *transitions
+    return transitions().select &:a? if transitions.empty?
+    a_Transitions( transitions )
+  end
+  alias a_tt a_transitions
+
+  # Expects an array of *S* transitions or transition ids, and returns an array
+  # of corresponding transition instances.
+  # 
+  def S_Transitions array
+    Transitions( array ).aT_all "transition identifiers", "be S", &:S?
+  end
+
+  # Expects an arbitrary number of *S* transitions or transition ids as
+  # arguments, and returns an array of corresponding transition instances.
+  # 
+  def S_transitions *transitions
+    return transitions().select &:S? if transitions.empty?
+    S_Transitions( transitions )
+  end
+  alias S_tt S_transitions
+
+  # Expects an array of *s* transitions or transition ids, and returns an array
+  # of corresponding transition instances.
+  # 
+  def s_Transitions array
+    Transitions( array ).aT_all "transition identifiers", "be s", &:s?
+  end
+
+  # Expects an arbitrary number of *s* transitions or transition ids as
+  # arguments, and returns an array of corresponding transition instances.
+  # 
+  def s_transitions *transitions
+    return transitions().select &:s? if transitions.empty?
+    s_Transitions( transitions )
+  end
+  alias s_tt s_transitions
+
+  # Expects an array of *T* transitions or transition ids, and returns an array
+  # of corresponding transition instances.
+  # 
+  def T_Transitions array
+    Transitions( array ).aT_all "transition identifiers", "be T", &:T?
+  end
+
+  # Expects an arbitrary number of *T* transitions or transition ids as
+  # arguments, and returns an array of corresponding transition instances.
+  # 
+  def T_transitions *transitions
+    return transitions().select &:T? if transitions.empty?
+    T_Transitions( transitions )
+  end
+  alias T_tt T_transitions
+
+  # Expects an array of *t* transitions or transition ids, and returns an array
+  # of corresponding transition instances.
+  # 
+  def t_Transitions array
+    Transitions( array ).aT_all "transition identifiers", "be t", &:t?
+  end
+
+  # Expects an arbitrary number of *t* transitions or transition ids as
+  # arguments, and returns an array of corresponding transition instances.
+  # 
+  def t_transitions *transitions
+    return transitions().select &:t? if transitions.empty?
+    t_Transitions( transitions )
+  end
+  alias t_tt t_transitions
+
+  # Name-returning versions of the node access methods.
+  # 
+  chain En: :Elements,
+        en: :elements,
+        Pn: :Places,
+        pn: :places,
+        Tn: :Transitions,
+        tn: :transitions,
+        nts: :ts_transitions,
+        ntS: :tS_transitions,
+        nTs: :Ts_transitions,
+        nTS: :TS_transitions,
+        nA: :A_transitions,
+        na: :a_transitions,
+        nS: :S_transitions,
+        ns: :s_transitions,
+        nT: :T_transitions,
+        nt: :t_transitions do |nodes| nodes.names end
+end # class YPetri::Net::NodeAccess

data/lib/y_petri/net/own_state.rb

@@ -1,10 +1,11 @@
+# encoding: utf-8
+
 # A mixin catering to the net's own state (ie. marking owned by the place
 # instances themselves) and its features.
 # 
 module YPetri::Net::OwnState
-  # State owned by the net. More precisely, an instance of the Net::State class,
-  # which is an Array subclass, containing the markings owned by the net's
-  # places as its elements.
+  # State owned by the net. This method returns an instance of +Net::State+
+  # class (a subclass of Array), containing marking owned by the net's places.
   # 
   def state
     State().new( marking )
@@ -28,7 +29,7 @@ module YPetri::Net::OwnState
     if transition_ids.nil? then
       fail TypeError, "Method #firing with no arguments is ambiguous for " +
         "nets with TS transitions!" if timed?
-      firing( tS_tt )
+      firing tS_tt
     else
       transition_ids.map { |id| tS_transition( id ).firing }
     end
@@ -60,4 +61,13 @@ module YPetri::Net::OwnState
   def delta place_ids=nil, transitions: tt
     fail NotImplementedError
   end
+
+  # Takes an array of A transition identifiers as an optional argument, and
+  # returns the array of their actions under current net state. If no argument
+  # is supplied, the array of assignments of all net's A transitions is returned.
+  #
+  def assignment transition_ids=nil
+    return assigment A_tt() if transition_ids.nil?
+    transition_ids.map { |id| A_transition( id ).action }
+  end
 end # module YPetri::Net::OwnState

data/lib/y_petri/net/state/feature/assignment.rb

@@ -0,0 +1,123 @@
+# encoding: utf-8
+
+# Firing of a Petri net A transition.
+# 
+class YPetri::Net::State::Feature::Assignment < YPetri::Net::State::Feature
+  attr_reader :place, :transition
+
+  class << self
+    # Customization of the Class#parametrize method.
+    # 
+    def parametrize *args
+      Class.instance_method( :parametrize ).bind( self ).( *args ).tap do |ç|
+        # Prepare the instance registry.
+        hsh = Hash.new do |ꜧ, id|
+          if id.is_a? self then # missing key "id" is an Assignment PS instance
+            ꜧ[ [ id.place, transition: id.transition ] ]
+          elsif id.is_a? ç.net.Place then # a single place
+            ç.construct_from_a_place_with_single_upstream_A_transition( id )
+          elsif id.is_a? Array and id.size == 1 then # single place again
+            ç.construct_from_a_place_with_single_upstream_A_transition( id.first )
+          elsif id.is_a? Array then
+            p = id.fetch( 0 )
+            t = id.fetch( 1 ).fetch( :transition )
+            if p.is_a? ç.net.Place and t.is_a? ç.net.Transition then
+              ꜧ[ id ] = ç.__new__( p, transition: t )
+            else
+              ꜧ[ [ ç.net.place( p ), transition: ç.net.transition( t ) ] ]
+            end
+          else
+            ç.construct_from_a_place_with_single_upstream_A_transition( id )
+          end
+        end # Hash.new do
+        # And assign it to @instances:
+        ç.instance_variable_set :@instances, hsh
+      end # tap
+    end # def parametrize
+
+    attr_reader :instances
+
+    alias __new__ new
+
+    # Constructor that enables special syntax of constructing
+    # Feature::Assignment instance from a single place, as long
+    # as this place has exactly 1 upstream A transition.
+    # 
+    def construct_from_a_place_with_single_upstream_A_transition( place )
+      pl = net.place( place )
+      aa = pl.upstream_arcs.select( &:A? )
+      n = aa.size
+      fail TypeError, "When constructing Feature::Assignment from a single" +
+        "place, its upstream arcs must contain exactly one A transition! " +
+        "(place #{pl} has #{n} upstream A transitions)" unless n == 1
+      __new__( pl, transition: aa.first )
+    end
+
+    # Constructor #new is redefined to use instance cache.
+    # 
+    def new *args
+      return instances[ *args ] if args.size == 1
+      instances[ args ]
+    end
+    alias to new
+  end
+
+  # The constructor of an assignment feature takes 1 ordered and 1 named
+  # (+:transition+) argument, which must identify the place and the transitions.
+  # 
+  def initialize place, transition: transition
+    @place = net.place( place )
+    @transition = net.transition( transition )
+    @place_index_in_codomain = @transition.codomain.index( @place ) or
+      fail TypeError, "The place (#@place) must belong to the codomain of " +
+        "the supplied A transition (#@transition)!"
+  end
+
+  # Extracts the receiver marking feature from the argument. This can be
+  # typically a simulation instance.
+  # 
+  def extract_from arg, **nn
+    case arg
+    when YPetri::Simulation then
+      # First, let's identify the relevant transition representation
+      t = arg.send( :A_transitions, transition ).first
+      # Then, let's get its assignment closure
+      closure = t.assignment_closure
+      # And finally, the feature extraction
+      Array( closure.call )[ @place_index_in_codomain ]
+    else
+      fail TypeError, "Argument type not supported!"
+    end
+  end
+
+  # Type of this feature.
+  # 
+  def type
+    :assignment
+  end
+
+  # A string briefly describing the assignment feature.
+  # 
+  def to_s
+    label
+  end
+
+  # Label for the firing feature (to use in the graphics etc.)
+  # 
+  def label
+    "A:#{place.name}:#{transition.name}"
+  end
+
+  # Inspect string of the firing feature.
+  # 
+  def inspect
+    "<Feature::Assignment to #{place.name or place} by #{transition.name or transition}>"
+  end
+
+  # Two assignment features are equal if their place and transition is equal.
+  # 
+  def == other
+    other.is_a? net.State.Feature.Assignment and
+      place == other.place && transition == other.transition
+  end
+end # YPetri::Net::State::Feature::Assignment

data/lib/y_petri/net/state/feature/delta.rb

@@ -3,44 +3,52 @@
 # Change of a Petri net place caused by a certain set of transitions.
 # 
 class YPetri::Net::State::Feature::Delta < YPetri::Net::State::Feature
-  attr_reader :place, :transitions, :step
+  attr_reader :place, :transitions
+  alias tt transitions
 
   class << self
     # Customization of the Class#parametrize method.
     # 
     def parametrize *args
       Class.instance_method( :parametrize ).bind( self ).( *args ).tap do |ç|
-        # First, prepare the hash of instances.
+        # First, prepare the instance registry.
         hsh = Hash.new do |ꜧ, id|
           if id.is_a? self then # missing key "id" is a Delta instance
             ꜧ[ [ id.place, transitions: id.transitions.sort_by( &:object_id ) ] ]
           else
             p = id.fetch( 0 )
             tt = id.fetch( 1 ).fetch( :transitions ) # value of :transitions key
-            if p.is_a? ç.net.Place and tt.all? { |t| t.is_a? ç.net.Transition }
-              if tt == tt.sort_by( &:object_id ) then
-                # Cache the instance.
-                ꜧ[ id ] = if tt.all? &:timed? then
-                            ç.timed( *id )
-                          elsif tt.all? &:timeless? then
-                            ç.timeless( *id )
-                          else
-                            fail TypeError, "Net::State::Feature::Delta only " +
-                              "admits the transition sets that are either " +
-                              "all timed, or all timeless!"
-                          end
-              else
-                ꜧ[ [ p, transitions: tt.sort_by( &:object_id ) ] ]
+            tt_array = Array( tt )
+            if tt == tt_array then
+              if p.is_a? ç.net.Place and tt.all? { |t| t.is_a? ç.net.Transition }
+                if tt == tt.sort_by( &:object_id ) then
+                  # Cache the instance.
+                  ꜧ[ id ] = if tt.all? &:timed? then
+                              ç.timed( *id )
+                            elsif tt.all? &:timeless? then
+                              fail TypeError, "Net::State::Feature::Delta does " +
+                                "not admit A transitions!" if tt.any? &:A?
+                              ç.timeless( *id )
+                            else
+                              fail TypeError, "Net::State::Feature::Delta only " +
+                                "admits the transition sets that are either " +
+                                "all timed, or all timeless!"
+                            end
+                else
+                  ꜧ[ [ p, transitions: tt.sort_by( &:object_id ) ] ]
+                end
+              else # convert place and transition ids to places and transitions
+                ꜧ[ [ ç.net.place( p ), transitions: ç.net.Transitions( tt ) ] ]
               end
-            else # convert place and transition ids to places and transitions
-              ꜧ[ [ ç.net.place( p ), transitions: ç.net.transitions( tt ) ] ]
+            else
+              ꜧ[ [ p, transitions: tt_array ] ]
             end
           end
         end
-        # And then, assign it to the :@instances variable.
+        # Then, assign it to the :@instances variable.
         ç.instance_variable_set :@instances, hsh
-      end
-    end
+      end # tap
+    end # def parametrize
 
     attr_reader :instances
 
@@ -51,7 +59,7 @@ class YPetri::Net::State::Feature::Delta < YPetri::Net::State::Feature
     # 
     def timed place, transitions: net.T_tt
       tt = begin
-             net.T_tt( transitions )
+             net.T_Transitions( transitions )
            rescue TypeError => err
              msg = "Transitions #{transitions} not recognized as timed " +
                "transitions in #{net}! (%s)"
@@ -66,13 +74,13 @@ class YPetri::Net::State::Feature::Delta < YPetri::Net::State::Feature
     # 
     def timeless place, transitions: net.t_tt
       tt = begin
-             net.t_tt( transitions )
+             net.t_Transitions( transitions )
            rescue TypeError => err
              msg = "Transitions #{transitions} not recognized as timed " +
                "transitions in #{net}! (%s)"
              raise TypeError, msg % err
            end
-      __new__( place, transitions: net.t_tt( transitions ) )
+      __new__( place, transitions: net.t_Transitions( transitions ) )
         .tap { |inst| inst.instance_variable_set :@timed, false }
     end
 
@@ -92,22 +100,21 @@ class YPetri::Net::State::Feature::Delta < YPetri::Net::State::Feature
   # 
   def initialize place, transitions: net.tt
     @place = net.place( place )
-    @transitions = net.transitions( transitions )
+    @transitions = net.Transitions( transitions )
   end
 
-  # Extracts the value of this feature from the supplied target
-  # (eg. a simulation).
+  # Extracts the value of this feature from the target (eg. a simulation).
+  # If the receiver delta feature is timed, this method requires an additional
+  # named argument +:delta_time+, alias +:Δt+.
   # 
-  def extract_from arg, **nn
-    # **nn is here because of timed / timeless possibility, where
-    # **nn would contain :step named argument.
+  def extract_from arg, **named_args
     case arg
     when YPetri::Simulation then
       if timed? then
-        tt = arg.send( :T_transitions, transitions )
-        -> Δt { tt.delta( Δt ).fetch( place ) }
+        arg.send( :T_Transitions, transitions )
+          .delta( named_args.must_have :delta_time, syn!: :Δt ).fetch( place )
       else
-        arg.send( :t_transitions, transitions ).delta.fetch( place )
+        arg.send( :t_Transitions, transitions ).delta.fetch( place )
       end
     else
       fail TypeError, "Argument type not supported!"
@@ -135,13 +142,18 @@ class YPetri::Net::State::Feature::Delta < YPetri::Net::State::Feature
   # A string briefly describing this delta feature.
   # 
   def to_s
-    place.name
+    label
   end
 
   # Label for the delta feature (to use in graphics etc.)
   # 
   def label
-    "Δ:#{place.name}:#{transitions.size}tt"
+    "Δ:#{place.name}:%s" %
+      if transitions.size == 1 then
+        transitions.first.name || transitions.first
+      else
+        "#{transitions.size}tt"
+      end
   end
 
   # Inspect string of the delta feature.
@@ -150,4 +162,12 @@ class YPetri::Net::State::Feature::Delta < YPetri::Net::State::Feature
     "<Feature::Delta Δ:#{place.name || place}:[%s]>" %
       transitions.names( true ).join( ', ' )
   end
+
+  # Delta features are equal if they are of equal PS and refer to
+  # the same place and transition set.
+  # 
+  def == other
+    other.is_a? net.State.Feature.Delta and
+      place == other.place && transitions == other.transitions
+  end
 end # class YPetri::Net::State::Feature::Delta