y_petri 2.1.3 → 2.1.6

data/lib/y_petri/net/state/features/record.rb

@@ -1,50 +1,157 @@
-class YPetri::Net::State
-  class Features
-    # A collection of values for a given set of state features.
+# encoding: utf-8
+
+# A collection of values for a given set of state features.
+# 
+class YPetri::Net::State::Features::Record < Array
+  class << self
+    delegate :State,
+             :net,
+             to: "Features()"
+
+    # Constructs a new Record object from a given collection of values.
     # 
-    class Record < Array
-      class << self
-        delegate :State,
-                 :net,
-                 to: "Features()"
-
-        # Construcs a new Record object from a given collection of values.
-        # 
-        def load values
-          new( values.dup )
-        end
-      end
+    def load values
+      new( values.dup )
+    end
+  end
 
-      delegate :Features,
-               :State,
-               :net,
-               :features,
-               to: "self.class"
+  delegate :Features,
+           :State,
+           :net,
+           :features,
+           to: "self.class"
 
-      # Outputs the record as a plain array.
-      # 
-      def dump precision: nil
-        features.map { |f| fetch( f ).round( precision ) }
-      end
+  # Outputs the record as a plain array.
+  # 
+  def dump precision: nil
+    features.map { |f| fetch( f ).round( precision ) }
+  end
 
-      # Returns an identified feature, or fails.
-      # 
-      def fetch feature
-        super begin
-                Integer( feature )
-              rescue TypeError
-                features.index State().feature( feature )
-              end
-      end
+  # Returns an identified feature, or fails.
+  # 
+  def fetch feature
+    super begin
+            Integer( feature )
+          rescue TypeError
+            features.index State().feature( feature )
+          end
+  end
+
+  # Returns the state instance implied by the receiver record, and a set of
+  # complementary marking clamps supplied as the argument.
+  # 
+  def state marking_clamps: {}
+    cc = marking_clamps.with_keys { |k| net.place k }.with_values! do |v|
+      case v
+      when YPetri::Place then v.marking
+      when ~:call then v.call
+      else v end
+    end
+    msg = "Marking clamps given in the argument taken together with this " +
+      "record's markings must complete the full state of the net!"
+    fail TypeError, msg unless
+      features.marking.map( &:place ) + net.places( cc.keys ) == net.places
+    State().new net.places.map do |place|
+      begin; cc.fetch place; rescue IndexError; fetch marking( place ) end
+    end
+  end
 
-      # Returns the state instance implied by the receiver record, and a set of
-      # complementary marking clamps supplied as the argument.
-      # 
-      def state marking_clamps: {}
-        State.new self, marking_clamps: marking_clamps
+  # Given a set of marking clamps complementary to the marking features of this
+  # record, reconstructs a Simulation instance with the corresponding state.
+  # If the net is timed, or if the construction of the simulation from the net
+  # has need for any special settings, these must be supplied to this method.
+  # (Timed nets eg. require +:time+ named argument for successful construction.)
+  # 
+  def reconstruct marking_clamps: {}, **settings
+    net.simulation marking_clamps: {}, marking: marking, **settings
+  end
+
+  # Expects a marking feature identifier (place identifier or Marking instance),
+  # and returns the value for that feature in this record. If an array of
+  # marking feature identifiers is supplied, it is mapped to the array of
+  # corresponding values. If no argument is given, values from this record for
+  # all the present marking features are returned.
+  # 
+  def marking id=nil
+    return marking( features.marking ) if id.nil?
+    case id
+    when Array then id.map { |id| marking id }
+    else fetch( features.marking id ) end
+  end
+
+  # Expects a flux feature identifier (transition identifier or Flux instance),
+  # and returns the value for that feature in this record. If an array of flux
+  # feature identifiers is supplied, it is mapped to the array of corresponding
+  # values. If no argument is given, values from this record for all the present
+  # flux features are returned.
+  # 
+  def flux id=nil
+    return flux( features.flux ) if id.nil?
+    case id
+    when Array then id.map { |id| flux net.transition( id ) }
+    else fetch( features.flux id ) end
+  end
+
+  # Expects a firing feature identifier (transition identifier or Firing
+  # instance), and returns the value for that feature in this record. If an
+  # array of firing feature identifiers is supplied, it is mapped to the array
+  # of corresponding values. If no argument is given, values from this record
+  # for all the present flux features are returned.
+  # 
+  def firing id=nil
+    return firing( features.firing ) if id.nil?
+    case id
+    when Array then id.map { |id| firing net.transition( id ) }
+    else fetch( features.firing id ) end
+  end
+
+  # Expects a gradient feature identifier (place identifier, or Gradient
+  # instance), qualified by an array of transitions (named argument
+  # +:transitions+, defaults to all timed transitions in the net), and returns
+  # the value for that feature in this record. If an array of gradient feature
+  # identifiers is supplied, it is mapped to the array of corresponding values.
+  # If no gradient feature identifier is given, values from this record for all
+  # the present gradient features are returned.
+  # 
+  def gradient id=nil, transitions: nil
+    if id.nil? then
+      return gradient( features.gradient ) if transitions.nil?
+      gradient( features.gradient.select do |f|
+                  f.transitions == transitions.map { |t| net.transition t }
+                end )
+    else
+      return gradient( id, transitions: net.T_tt ) if transitions.nil?
+      case id
+      when Array then
+        pl.map { |id| gradient id, transitions: transitions }
+      else
+        fetch( features.gradient id, transitions: transitions )
       end
+    end
+  end
 
-      delegate :reconstruct, to: :state
-    end # class Record
-  end # class Features
-end # YPetri::Net::State
+  # Expects a gradient feature identifier (place identifier, or Delta instance),
+  # qualified by an array of transitions (named argument +:transitions+,
+  # defaults to all timed transitions in the net), and returns the value for
+  # that feature in this record. If an array of delta feature identifiers is
+  # supplied, it is mapped to the array of corresponding values. If no delta
+  # feature identifier is given, values from this record for all the present
+  # delta features are returned.
+  # 
+  def delta pl=nil, transitions: nil
+    if id.nil? then
+      return delta( features.delta ) if transitions.nil?
+      delta( features.delta.select do |f|
+               f.transitions == transitions.map { |t| net.transition t }
+             end )
+    else
+      return delta( id, transitions: net.tt ) if transitions.nil?
+      case id
+      when Array then
+        id.map { |id| delta id, transitions: transitions }
+      else
+        fetch( features.delta id, transitions: net.tt( transitions ) )
+      end
+    end
+  end
+end # class YPetri::Net::State::Features::Record

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

@@ -1,126 +1,282 @@
 # encoding: utf-8
 
-class YPetri::Net::State
-  # A set of state features.
-  # 
-  class Features < Array
-    require_relative 'features/record'
-    require_relative 'features/dataset'
-
-    class << self
-      # Customization of the parametrize method for the Features class: Its
-      # dependents Record and Dataset are also parametrized.
-      # 
-      def parametrize parameters
-        Class.new( self ).tap do |subclass|
-          parameters.each_pair { |symbol, value|
-            subclass.define_singleton_method symbol do value end
-          }
-          subclass.param_class( { Record: Record, Dataset: Dataset },
-                                with: { Features: subclass } )
-        end
-      end
-
-      delegate :net,
-               :Feature,
-               :feature,
-               to: "State()"
-
-      delegate :Marking,
-               :Firing,
-               :Gradient,
-               :Flux,
-               :Delta,
-               to: "Feature()"
-
-      delegate :load, to: :Record
-
-      alias __new__ new
-
-      def new features
-        ff = features.map &method( :feature )
-        __new__( ff ).tap do |inst|
-          # Parametrize them <em>one more time</em> with Features instance.
-          # Banged version of #param_class! ensures that #Record, #Dataset
-          # methods are shadowed.
-          inst.param_class!( { Record: Record(), Dataset: Dataset() },
-                             with: { features: inst } )
-        end
-      end
-
-      def marking places=net.pp
-        new net.pp( places ).map { |p| Marking( p ) }
-      end
-
-      def firing transitions=net.tS_tt
-        new net.tS_tt( transitions ).map { |t| Firing( t ) }
-      end
-
-      def gradient places=net.pp, transitions: net.T_tt
-        tt = net.T_tt( transitions )
-        new net.pp( places ).map { |p|
-          Gradient( p, transitions: tt )
-        }
-      end
-
-      def flux transitions=net.TS_tt
-        new net.TS_tt( transitions ).map { |t| Flux( t ) }
-      end
+# A set of state features.
+# 
+class YPetri::Net::State::Features < Array
+  require_relative 'features/record'
 
-      def delta places=net.pp, transitions: net.tt
-        transitions = net.tt( transitions )
-        new net.pp( places ).map { |p|
-          Delta( p, transitions: transitions )
+  class << self
+    # Customization of the parametrize method for the Features class: Its
+    # dependents Record and Dataset are also parametrized.
+    # 
+    def parametrize parameters
+      Class.new( self ).tap do |ç|
+        parameters.each_pair { |symbol, value|
+          ç.define_singleton_method symbol do value end
         }
+        ç.param_class( { Record: Record,
+                         Dataset: YPetri::Net::DataSet },
+                       with: { Features: ç } )
       end
     end
 
-    delegate :State,
-             :net,
+    delegate :net,
              :Feature,
              :feature,
-             :Marking,
+             to: "State()"
+
+    delegate :Marking,
              :Firing,
              :Gradient,
              :Flux,
              :Delta,
-             :load,
-             to: "self.class"
+             to: "Feature()"
 
-    # Extracts the features from a given target
-    # 
-    def extract_from target, **nn
-      Record().new( map { |feature| feature.extract_from( target, **nn ) } )
+    delegate :load, to: "Record()"
+
+    alias __new__ new
+
+    def new features
+      array = features.map &method( :feature )
+      __new__( array ).tap do |inst|
+        # Parametrize them <em>one more time</em> with Features instance.
+        # Banged version of #param_class! ensures that #Record, #Dataset
+        # methods are shadowed.
+        inst.param_class!( { Record: Record(), Dataset: Dataset() },
+                           with: { features: inst } )
+      end
     end
 
-    # Constructs a new dataset from these features.
+    # Takes an array of marking feature identifiers (places, Marking instances),
+    # and returns the corresponding array of marking features valid for the
+    # current net. If no argument is given, an array of all the marking features
+    # of the current net is returned.
     # 
-    def new_dataset
-      Dataset().new
+    def marking arg=nil
+      return marking net.pp if arg.nil?
+      new arg.map { |id| Marking id }
     end
 
-    # Feature summation -- of feature class.
+    # Takes an array of firing feature identifiers (transitions, Firing
+    # instances), and returns the corresponding array of firing features valid
+    # for the current net. If no argument is given, an array of all the firing
+    # features of the current net is returned.
     # 
-    def + other
-      self.class.new( super )
+    def firing arg=nil
+      return firing net.tS_tt if arg.nil?
+      new arg.map { |id| Firing id }
     end
 
-    # Feature summation -- of feature class.
+    # Takes an array of gradient feature identifiers (places, Marking instances),
+    # qualified by an array of transitions (named argument +:transitions+,
+    # defaults to all the timed transitions in the net), and returns the
+    # corresponding array of gradient features valid for the current net. If no
+    # argument is given, an array of all the gradient features qualified by the
+    # +:transitions+ argument is returned.
     # 
-    def - other
-      self.class.new( super )
+    def gradient arg=nil, transitions: nil
+      if arg.nil? then
+        return gradient net.pp, transitions: net.T_tt if transitions.nil?
+        gradient net.pp, transitions: transitions
+      else
+        return new arg.map { |id| Gradient id } if transitions.nil?
+        new arg.map { |id| Gradient id, transitions: transitions }
+      end
     end
 
-    # Feature summation -- of feature class.
+    # Takes an array of flux feature identifiers (transitions, Flux instances),
+    # and returns the corresponding array of flux features valid for the current
+    # net. If no argument is given, an array of all the flux features of the
+    # current net is returned.
     # 
-    def * other
-      self.class.new( super )
+    def flux arg=nil
+      return flux net.TS_tt if arg.nil?
+      new arg.map { |t| Flux t }
     end
 
-    # Feature labels.
+    # Takes an array of delta feature identifiers (places, Delta instances),
+    # qualified by an array of transitions (named argument +:transitions+,
+    # defaults to all the transitions in the net), and returns the corresponding
+    # array of delta features valid for the current net. If no argument is
+    # given, an array of all the delta features qualified by the +:transitions+
+    # argument is returned.
     # 
-    def labels
-      map &:label
+    def delta arg=nil, transitions: nil
+      if arg.nil? then
+        return delta net.pp, transitions: net.tt if transitions.nil?
+        delta net.pp, transitions: transitions
+      else
+        return new arg.map { |id| Delta id } if transitions.nil?
+        new arg.map { |id| Delta id, transitions: transitions }
+      end
+    end
+  end
+
+  delegate :State,
+           :net,
+           :Feature,
+           :feature,
+           :Marking,
+           :Firing,
+           :Gradient,
+           :Flux,
+           :Delta,
+           to: "self.class"
+
+  delegate :load,
+           to: "Record()"
+
+  alias new_record load
+
+  # Extracts the features from a given target
+  # 
+  def extract_from target, **nn
+    new_record( map { |feature| feature.extract_from( target, **nn ) } )
+  end
+
+  # Constructs a new dataset from these features.
+  # 
+  def new_dataset *args, &blk
+    Dataset().new *args, &blk
+  end
+
+  # Feature summation -- of feature class.
+  # 
+  def + other
+    self.class.new( super )
+  end
+
+  # Feature summation -- of feature class.
+  # 
+  def - other
+    self.class.new( super )
+  end
+
+  # Feature summation -- of feature class.
+  # 
+  def * other
+    self.class.new( super )
+  end
+
+  # Feature labels.
+  # 
+  def labels
+    map &:label
+  end
+
+  # Expects a hash identifying a set of features, that is a subset of the
+  # current set of features.
+  # 
+  def reduce_features features
+    net.State.features( features ).tap do |ff|
+      msg = "The argument must identify a subset of the current feature set!"
+      fail TypeError, msg unless ( ff - self ).empty?
+    end
+  end
+
+  # Returns the subset of marking features.
+
+
+  # Expects a marking feature identifier (place identifier or Marking instance),
+  # and returns the corresponding feature from this feature set. If an array of
+  # marking feature identifiers is supplied, it is mapped to the array of
+  # corresponding features from this feature set. If no argument is given, all
+  # the marking features from this set are returned.
+  #
+  def marking id=nil
+    return marking( select { |f| f.is_a? Marking() } ) if id.nil?
+    case id
+    when Array then self.class.new( id.map { |id| marking id } )
+    else
+      Marking( id ).tap do |feature|
+        include? feature or
+          fail KeyError, "No marking feature '#{id}' in this feature set!"
+      end
+    end
+  end
+
+  # Expects a firing feature idenfier (tS transition identifier, or Firing
+  # instance), and returns the corresponding feature from this feature set. If
+  # an array of firing feature identifiers is supplied, it is mapped to the
+  # array of corresponding features from this feature set. If no argument is
+  # given, all the firing features from this set are returned.
+  #
+  def firing id=nil
+    return firing( select { |f| f.is_a? Firing() } ) if id.nil?
+    case id
+    when Array then self.class.new( id.map { |id| firing id } )
+    else
+      Firing( id ).tap do |feature|
+        include? feature or
+          fail KeyError, "No firing feature '#{id}' in this feature set!"
+      end
+    end
+  end
+
+  # Expects a flux feature identifier (TS transition identifier, or Flux
+  # instance), and returns the corresponding feature from this feature set. If
+  # an array of flux feature identifiers is supplied, it is mapped to the array
+  # of corresponding features from this feature set. If no argument is given,
+  # all the flux features from this set are returned.
+  #
+  def flux id=nil
+    return flux( select { |f| f.is_a? Flux() } ) if id.nil?
+    case id
+    when Array then self.class.new( id.map { |id| flux id } )
+    else
+      Flux( id ).tap do |feature|
+        include? feature or
+          fail KeyError, "No flux feature '#{id}' in this feature set!"
+      end
+    end
+  end
+
+  # Expects a gradient feature identifier (place identifier, or Gradient
+  # instance), qualified by an array of transitions (named argument
+  # +:transitions+, defaults to all timed transitions in the net), and
+  # returns the corresponding feature from this feature set. If an array of
+  # gradient feature identifiers is supplied, it is mapped to the array of
+  # corresponding features from this feature set. If no argument is given,
+  # all the gradient features from this feature set are returned.
+  # 
+  def gradient id=nil, transitions: nil
+     if id.nil? then
+       return gradient( select { |f| f.is_a? Gradient() } ) if transitions.nil?
+       gradient.select { |f| f.transitions == net.tt( transitions ) }
+     else
+       case id
+       when Array then
+         self.class.new( id.map { |id| gradient id, transitions: transitions } )
+       else
+         Gradient( id, transitions: transitions ).tap do |feature|
+           include? feature or
+             fail KeyError, "No gradient feature '#{id}' in this fature set!"
+         end
+       end
+     end
+  end
+
+  # Expects a delta feature identifier (place identifier, or Gradient instance),
+  # qualified by an array of transitions (named argument +:transitions+,
+  # defaulting to all the transtitions in the net), and returns the
+  # corresponding feature from this feature set. If an array of delta feature
+  # identifiers is supplied, it is mapped to the array of corresponding features
+  # from thie feature set.
+  #
+  def delta
+    if id.nil? then
+      return delta( select { |f| f.is_a? Delta() } ) if transitions.nil?
+      delta.select { |f| f.transitions == net.tt( transitions ) }
+    else
+      case id
+      when Array then
+        self.class.new( id.map { |id| delta id, transitions: transitions } )
+      else
+        Delta( id, transitions: transitions ).tap do |feature|
+          include? feature or
+            fail KeyError, "No delta feature '#{id}' in this feature set!"
+        end
+      end
     end
-  end # class Features
-end # YPetri::Net::State
+  end
+end # YPetri::Net::State::Features