y_petri 2.2.4 → 2.3.2

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

@@ -1,6 +1,7 @@
 # encoding: utf-8
 
-# Firing of a Petri net tS transition.
+# Firing of an S transition. (Firing is only defined on S transitions, whose
+# action can be computed as firing * stoichometry_vector_of_the_transition.)
 # 
 class YPetri::Net::State::Feature::Firing < YPetri::Net::State::Feature
   attr_reader :transition
@@ -10,25 +11,27 @@ class YPetri::Net::State::Feature::Firing < YPetri::Net::State::Feature
     # 
     def parametrize *args
       Class.instance_method( :parametrize ).bind( self ).( *args ).tap do |ç|
-        ç.instance_variable_set( :@instances,
-                                 Hash.new do |hsh, id|
-                                   case id
-                                   when self then
-                                     hsh[ id.transition ]
-                                   when ç.net.Transition then
-                                     t = begin
-                                           ç.net.tS_transitions( [ id ] ).first
-                                         rescue TypeError => err
-                                           msg = "Transition #{id} not " +
-                                             "recognized as tS transition in " +
-                                             "net #{ç.net}! (%s)"
-                                           raise TypeError, msg % err
-                                         end
-                                     hsh[ id ] = ç.__new__( t )
-                                   else
-                                     hsh[ ç.net.transition( id ) ]
-                                   end
-                                 end )
+        # First, prepare the hash of instances.
+        hsh = Hash.new do |hsh, id|
+          case id
+          when self then # missing key "id" is a Firing instance
+            hsh[ id.transition ]
+          when ç.net.Transition then
+            t = begin
+                  ç.net.S_transitions( id ).first
+                rescue TypeError => err
+                  msg = "Transition #{id} not " +
+                    "recognized as tS transition in " +
+                    "net #{ç.net}! (%s)"
+                  raise TypeError, msg % err
+                end
+            hsh[ id ] = t.timed? ? ç.timed( t ) : ç.timeless( t )
+          else
+            hsh[ ç.net.transition( id ) ]
+          end
+        end
+        # And then, assign it to the :@instances variable.
+        ç.instance_variable_set :@instances, hsh
       end
     end
 
@@ -45,6 +48,21 @@ class YPetri::Net::State::Feature::Firing < YPetri::Net::State::Feature
     def of id
       new id
     end
+
+    # Expects a single timed transition and constructs a timed firing feature.
+    # 
+    def timed id
+      __new__( net.T_tt( id ).first )
+        .tap { |i| i.instance_variable_set :@timed, true }
+    end
+
+    # Expects a single timeless transition and constructs a timeless firing
+    # feature.
+    # 
+    def timeless id
+      __new__( net.t_tt( id ).first )
+        .tap { |i| i.instance_variable_set :@timed, false }
+    end
   end
 
   # The constructor of a marking feature takes exactly one argument (transition
@@ -54,22 +72,40 @@ class YPetri::Net::State::Feature::Firing < YPetri::Net::State::Feature
     @transition = net.transition( transition )
   end
 
-  # Extracts the receiver marking feature from the argument. This can be
-  # typically a simulation instance.
+  # Extracts the value of this feature from the target (eg. a simulation).
+  # If the receiver firing feature is timed, this method requires an additional
+  # named argument +:delta_time+, alias +:Δt+.
   # 
-  def extract_from arg, **nn
+  def extract_from arg, **named_args
     case arg
     when YPetri::Simulation then
-      arg.send( :tS_transitions, [ transition ] ).first.firing
+      if timed? then
+        arg.send( :TS_transitions, transition ).first
+          .firing( named_args.must_have :delta_time, syn!: :Δt )
+      else
+        arg.send( :tS_transitions, transition ).first.firing
+      end
     else
       fail TypeError, "Argument type not supported!"
     end
   end
 
+  # Is the delta feature timed?
+  # 
+  def timed?
+    @timed
+  end
+
+  # Opposite of +#timed?+.
+  # 
+  def timeless?
+    ! timed?
+  end
+
   # Type of this feature.
   # 
   def type
-    :flux
+    :firing
   end
 
   # A string briefly describing the firing feature.
@@ -89,4 +125,11 @@ class YPetri::Net::State::Feature::Firing < YPetri::Net::State::Feature
   def inspect
     "<Feature::Firing of #{transition.name ? transition.name : transition}>"
   end
+
+  # Firing features are equal if they are of equal PS and refer
+  # to the same transition.
+  # 
+  def == other
+    other.is_a? net.State.Feature.Firing and transition == other.transition
+  end
 end # YPetri::Net::State::Feature::Firing

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

@@ -17,7 +17,7 @@ class YPetri::Net::State::Feature::Flux < YPetri::Net::State::Feature
                                      hsh[ id.transition ]
                                    when ç.net.Transition then
                                      t = begin
-                                           ç.net.TS_transitions( [ id ] ).first
+                                           ç.net.TS_transitions( id ).first
                                          rescue TypeError => err
                                            msg = "Transition #{id} not " +
                                              "recognized as TS transition in " +
@@ -60,7 +60,7 @@ class YPetri::Net::State::Feature::Flux < YPetri::Net::State::Feature
   def extract_from arg, **nn
     case arg
     when YPetri::Simulation then
-      arg.send( :TS_transitions, [ transition ] ).first.flux
+      arg.send( :TS_transitions, transition ).first.flux
     else
       fail TypeError, "Argument type not supported!"
     end
@@ -89,4 +89,11 @@ class YPetri::Net::State::Feature::Flux < YPetri::Net::State::Feature
   def inspect
     "<Feature::Flux of #{transition.name ? transition.name : transition}>"
   end
+
+  # Flux features are equal if they are of equal PS and refer to the
+  # same transition.
+  #
+  def == other
+    other.is_a? net.State.Feature.Flux and transition == other.transition
+  end
 end # class YPetri::Net::State::Feature::Flux

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

@@ -4,6 +4,7 @@
 # 
 class YPetri::Net::State::Feature::Gradient < YPetri::Net::State::Feature
   attr_reader :place, :transitions
+  alias tt transitions
 
   class << self
     # Customization of the Class#parametrize method.
@@ -16,25 +17,28 @@ class YPetri::Net::State::Feature::Gradient < YPetri::Net::State::Feature
             ꜧ[ [ id.place, transitions: id.transitions.sort_by( &:object_id ) ] ]
           else
             p = id.fetch( 0 )
-            tt = id
-              .fetch( 1 )
-              .fetch( :transitions )
-            if p.is_a? ç.net.Place and tt.all? { |t| t.is_a? ç.net.Transition }
-              tt_sorted = tt.sort_by &:object_id
-              if tt == tt_sorted then
-                tt = begin
-                       ç.net.T_transitions( tt )
-                     rescue TypeError => err
-                       msg = "Transitions #{tt} not recognized as T " +
-                         "transitions in net #{ç.net}! (%s)"
-                       raise TypeError, msg % err
-                     end
-                ꜧ[ id ] = ç.__new__( *id )
+            tt = id.fetch( 1 ).fetch( :transitions )
+            tt_array = Array( tt )
+            if tt == tt_array then
+              if p.is_a? ç.net.Place and tt.all? { |t| t.is_a? ç.net.Transition }
+                tt_sorted = tt.sort_by &:object_id
+                if tt == tt_sorted then
+                  tt = begin
+                         ç.net.T_Transitions( tt )
+                       rescue TypeError => err
+                         msg = "Transitions #{tt} not recognized as T " +
+                           "transitions in net #{ç.net}! (%s)"
+                         raise TypeError, msg % err
+                       end
+                  ꜧ[ id ] = ç.__new__( *id )
+                else
+                  ꜧ[ [ p, transitions: tt.sort_by( &:object_id ) ] ]
+                end
               else
-                ꜧ[ [ p, transitions: tt.sort_by( &:object_id ) ] ]
+                ꜧ[ [ ç.net.place( p ), transitions: ç.net.Transitions( tt ) ] ]
               end
             else
-              ꜧ[ [ ç.net.place( p ), transitions: ç.net.transitions( tt ) ] ]
+              ꜧ[ [ p, transitions: tt_array ] ]
             end
           end
         end
@@ -63,7 +67,7 @@ class YPetri::Net::State::Feature::Gradient < YPetri::Net::State::Feature
   # 
   def initialize *id
     @place = net.place id.fetch( 0 )
-    @transitions = net.transitions id.fetch( 1 ).fetch( :transitions )
+    @transitions = net.Transitions id.fetch( 1 ).fetch( :transitions )
   end
 
   # Extracts the receiver gradient feature from the argument. This can be
@@ -72,7 +76,7 @@ class YPetri::Net::State::Feature::Gradient < YPetri::Net::State::Feature
   def extract_from arg, **nn
     case arg
     when YPetri::Simulation then
-      arg.send( :T_transitions, transitions ).gradient.fetch( place )
+      arg.send( :T_Transitions, transitions ).gradient.fetch( place )
     else
       fail TypeError, "Argument type not supported!"
     end
@@ -93,7 +97,12 @@ class YPetri::Net::State::Feature::Gradient < YPetri::Net::State::Feature
   # Label for the gradient 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 gradient feature.
@@ -102,4 +111,12 @@ class YPetri::Net::State::Feature::Gradient < YPetri::Net::State::Feature
     "<Feature::Gradient ∂:#{place.name || place}:[%s]>" %
       transitions.names( true ).join( ', ' )
   end
+
+  # Gradient 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.Gradient and
+      place == other.place && transitions == other.transitions
+  end
 end # class YPetri::Net::State::Feature::Gradient

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

@@ -19,9 +19,8 @@ class YPetri::Net::State::Feature::Marking < YPetri::Net::State::Feature
                                      p = begin
                                            ç.net.place id
                                          rescue TypeError => err
-                                           msg = "Place #{id} not recognized " +
-                                             "a place in net #{ç.net}! (%s)"
-                                           raise TypeError, msg % err
+                                           raise TypeError, "Place #{id} not " +
+                                             "present in net #{ç.net}! (#{err})"
                                          end
                                      hsh[ id ] = ç.__new__( id )
                                    else
@@ -59,8 +58,7 @@ class YPetri::Net::State::Feature::Marking < YPetri::Net::State::Feature
   def extract_from arg, **nn
     case arg
     when YPetri::Simulation then
-      # now we have to investigate the case when place.name is A_phase, why the heck does it fail
-      arg.m( [ place ] ).first
+      arg.m( place ).first
     else
       fail TypeError, "Argument type not supported!"
     end
@@ -89,4 +87,11 @@ class YPetri::Net::State::Feature::Marking < YPetri::Net::State::Feature
   def inspect
     "<Feature::Marking of #{place.name ? place.name : place}>"
   end
+
+  # Marking features are equal if they are of equal PS and refer
+  # to the same place.
+  # 
+  def == other
+    other.is_a? net.State.Feature.Marking and place == other.place
+  end
 end # YPetri::Net::State::Feature::Marking

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

@@ -8,6 +8,7 @@ class YPetri::Net::State::Feature
   require_relative 'feature/gradient'
   require_relative 'feature/flux'
   require_relative 'feature/delta'
+  require_relative 'feature/assignment'
 
   class << self
     def parametrize parameters
@@ -21,28 +22,40 @@ class YPetri::Net::State::Feature
         ç.instance_variable_set :@Gradient, Gradient.parametrize( State: sç )
         ç.instance_variable_set :@Flux, Flux.parametrize( State: sç )
         ç.instance_variable_set :@Delta, Delta.parametrize( State: sç )
+        ç.instance_variable_set :@Assignment, Assignment.parametrize( State: sç )
       end
     end
 
-    delegate :net,
-             to: "State()"
+    delegate :net, to: "State()"
 
+    # Marking feature constructor. Takes a single place identifying argument.
+    # 
     def Marking id=L!
       return @Marking if id.local_object?
       case id
       when Marking() then id
       when Marking then Marking().of( id.place )
-      else Marking().of( id ) end # assume it's a place
+      else Marking().of( id ) end # assume place
     end
 
+    # Firing feature constructor. Takes a single argument, which must identify
+    # an S transition (nonstoichiometric transitions don't have firing, though
+    # they do have action.)
+    # 
     def Firing id=L!
       return @Firing if id.local_object?
       case id
       when Firing() then id
       when Firing then Firing().of( id.transition )
-      else Firing().of( id ) end # assume it's a place
+      else Firing().of( id ) end # assume transition
     end
 
+    # Gradient feature constructor. Takes a single ordered argument, which must
+    # identify a place, and an optional named argument +:transitions+, which must
+    # contain an array of T transition identifyers (gradient is defined as time
+    # derivative, so timeless transitions are not eligible). If not given, the
+    # gradient feature is constructed with respect to all net's T transitions.
+    # 
     def Gradient id=L!, transitions: net.T_tt
       return @Gradient if id.local_object?
       case id
@@ -50,32 +63,113 @@ class YPetri::Net::State::Feature
       when Gradient then
         Gradient().of( id.place, transitions: id.transitions )
       else
-        Gradient().of( id, transitions: transitions )
-      end # assume it's a place
+        Gradient().of( id, transitions: transitions ) # assume place
+      end
     end
 
+    # Flux feature constructor. Takes a single argument, which must identify
+    # a TS transition. Flux is defined as time derivative of firing.
+    # 
     def Flux id=L!
       return @Flux if id.local_object?
       case id
       when Flux() then id
       when Flux then Flux().of( id.transition )
-      else
-        Flux().of( id )
-      end # assume it's a place
+      else Flux().of( id ) end # assume transition
     end
 
+    # Delta feature constructor. Takes a single ordered argument, which must
+    # identify a place, and an optional named argument +:transitions+, which
+    # must contain an array of transition idetifyers. If not given, the delta
+    # feature is constructed with respect to all net's transitions.
+    #
+    # Furthermore, if the +:transitions+ argument is given, the transitions must
+    # be either all timeless, or all timed. Delta features are thus of 2 kinds:
+    # timed and timeless (can be inquired via +#timed?+). When used to extract
+    # values from the target object, timeless delta merely returns a value, while
+    # timed returns unary closure waiting for Δt argument to return delta for
+    # that Δt (if you want the rate directly, use a gradient feature).
+    # 
     def Delta id=L!, transitions: net.tt
       return @Delta if id.local_object?
       case id
       when Delta() then id
       when Delta then
         Delta().of( id.place, transitions: id.transitions )
-      else Delta().of( id, transitions: transitions ) end # assume it's a place
+      else
+        Delta().of( id, transitions: transitions )
+      end # assume place
+    end
+
+    # Assignment feature constructor. Takes a single ordered argument, which
+    # must identify a place, and an optional argument +:transition+, which
+    # must identify a single A (assignment) transition. The feature extracts
+    # the assignment action from the transition to the place. If the
+    # +:transition+ named argument is not given, the place's upstream arcs
+    # must contain exactly one A transition.
+    # 
+    def Assignment id=L!, transition: L!
+      return @Assignment if id.local_object? && transition.local_object?
+      case id
+      when Assignment() then id
+      when Assignment then
+        Assignment().to( id.place, transition: id.transition )
+      else
+        fail ArgumentError, "No place given!" if id.local_object?
+        if transition.local_object? then
+          Assignment().to( id )
+        else
+          Assignment().to( id, transition: transition )
+        end
+      end
+    end
+
+    # Takes a single argument, and infers a feature from it in the following way:
+    # A +net.State.Feature+ instance is returned unchanged. Place or place id is
+    # converted to a marking feature. Otherwise, the argument is treated as a
+    # transition, and is converted to either a flux feature (if timed), or a
+    # firing feature (if timeless).
+    # 
+    def infer_from_node( arg )
+      case arg
+      when self then return arg
+      when Marking then return Marking().of( arg.place )
+      when Firing then return Firing().of( arg.transition )
+      when Gradient then
+        return Gradient().of( arg.place, transitions: arg.transitions )
+      when Flux then return Flux().of( arg.transition )
+      when Delta then
+        return Delta().of( arg.place, transitions: arg.transitions )
+      when Assignment then
+        return Assignment().to( arg.place, transitions: arg.transition )
+      else # treated as a place or transition id
+        e, type = begin
+                    [ net.place( arg ), :place ]
+                  rescue TypeError, NameError
+                    [ net.transition( arg ), :transition ]
+                  end
+      end
+      case type
+      when :place then Marking( e )
+      when :transition then
+        fail TypeError, "Flux / firing features can only be auto-inferred " +
+          "from S transitions! (#{arg} was given)" unless e.S?
+        e.timed? ? Flux( e ) : Firing( e )
+      end
     end
   end # class << self
 
   delegate :net,
            :State,
-           :Marking, :Firing, :Gradient, :Flux, :Delta,
            to: "self.class"
+
+  # Interpolation operator +%+ acts as an alias for the +#extract_from+ feature
+  # extraction method.
+  # 
+  def % operand
+    args = Array( operand )
+    named_args = args.extract_options!
+    arg = args.first
+    extract_from arg, **named_args
+  end
 end # class YPetri::Net::State::Feature