y_petri 2.2.4 → 2.3.2

data/lib/y_petri/core.rb

@@ -1,64 +1,66 @@
 # encoding: utf-8
 
-require_relative 'core/timed'
-require_relative 'core/timeless'
-
+# This class represents a simulator.
+# 
 class YPetri::Core
+  require_relative 'core/timed'
+  require_relative 'core/timeless'
+  require_relative 'core/guarded'
+
+  ★ YPetri::Simulation::Dependency
+
   DEFAULT_METHOD = :pseudo_euler
 
-  module Guarded
-    # Guarded simulation.
+  class << self
+    # Timed subclass of self.
     # 
-    def guarded?
-      true
+    def timed
+      Class.new self do
+        include Timed
+        def timed?; true end
+        def timeless?; false end
+      end
     end
 
-    # Guarded version of the method.
+    # Timeless subclass of self.
     # 
-    def increment_marking_vector( delta )
-      try "to update marking" do
-        super( note( "Δ state if tS transitions fire once",
-                     is: Δ_if_tS_fire_once ) +
-               note( "Δ state if tsa transitions fire once",
-                     is: Δ_if_tsa_fire_once ) )
+    def timeless
+      Class.new self do
+        include Timeless
+        def timed?; false end
+        def timeless?; true end
       end
     end
 
-    # Guarded version of the method.
+    # Vanilla simulator is not guarded.
+    # 
+    def guarded?; false end
+
+    # Guarded subclass of self (not working yet).
     # 
-    def A_all_fire!
-      try "to fire the assignment transitions" do
-        super
+    def guarded
+      Class.new self do
+        include Guarded
+        def guarded?; true end
       end
     end
   end
 
-  include YPetri::Simulation::Dependency
-
-  delegate :simulation, to: "self.class"
-  delegate :alert, to: :recorder
+  attr_reader :simulation_method
 
-  class << self
-    alias __new__ new
-
-    def new( method: nil, guarded: false, **nn )
-      # Alow for named arg. alias :simulation_method
-      sm = method || nn[:simulation_method] || DEFAULT_METHOD
-      using_simulation_method( sm, guarded: guarded ).__new__
-    end
-
-    def using_simulation_method symbol, guarded: false
-      simulation_method_module = const_get( symbol.to_s.camelize )
-      # TODO: "guarded" argument not handled yet
-      Class.new self do prepend( simulation_method_module ) end
-    end
+  def initialize method: nil, guarded: false, **named_args
+    @simulation_method = method || DEFAULT_METHOD
+    method_init # defined in Timed::Methods and Timeless::Methods
   end
 
-  # Simulation is not guarded by default.
-  # 
-  def guarded?
-    false
-  end
+  delegate :simulation,
+           :timed?,
+           :timeless?,
+           :guarded?,
+           to: "self.class"
+
+  delegate :alert!,
+           to: :recorder
 
   # Delta for free places from timeless transitions.
   # 
@@ -95,6 +97,6 @@ class YPetri::Core
   # Fires assignment transitions.
   # 
   def assignment_transitions_all_fire!
-    simulation.A_assignment_closure.call
+    simulation.A_direct_assignment_closure.call
   end
 end # class YPetri::Core

data/lib/y_petri/net/data_set.rb

@@ -1,6 +1,29 @@
 # encoding: utf-8
 
-# Dataset is a collection of labeled state records.
+# +DataSet+ is a collection of labeled state records. It is a subclass of +Hash+
+# class, whose keys are known as _events_, and values are data points (arrays)
+# that correspond to saved records (+YPetri::Net::State::Features::Record+) under
+# a given feature set (+YPetri::Net::State::Features+). +DataSet+ class is
+# intended to be parametrized with a specific feature set. Apart from the methods
+# inherited from +Hash+, +YPetri::Net::DataSet+ can load a record at a given
+# event (+#record+ method), reconstruct a simulation at a given event
+# (+#reconstruct+ method), return columns corresponding to features (+#series+
+# method) and perform feature selection (+#marking+, +#firing+, +#flux+,
+# +#gradient+, +#delta+, +#assignment+, and +#reduced_features+ for mixed feature
+# sets). Apart from standard inspection methods, +DataSet+ has methods +#print+
+# and +#plot+ for visual presentation. Also, +DataSet+ has methods specially
+# geared towards records of timed simulations, whose events are points in time.
+# Method +#interpolate+ uses linear interpolation to find the approximate state
+# of the system at some exact time using linear interpolation between the nearest
+# earlier and later data points (which can be accessed respectively by +#floor+
+# and +#ceiling+ methods). Interpolation is used for resampling the set
+# (+#resample+ method).
+#
+# Finally, it is possible that especially professional statisticians have
+# written, or are planning to write, a +DataSet+ class better than this one.
+# If I discover a good +DataSet+ class in the future, I would like to inherit
+# from it or otherwise integrate with it for the purposes of
+# +YPetri::Net::DataSet+.
 # 
 class YPetri::Net::DataSet < Hash
   class << self
@@ -19,18 +42,12 @@ class YPetri::Net::DataSet < Hash
     private :__new__
 
     delegate :net, to: :features
-    delegate :State, to: :net
-    delegate :Marking, :Firing, :Flux, :Gradient, :Delta,
-             to: "State()"
   end
 
   alias events keys
-  alias records values
 
   delegate :features,
            :net,
-           :State,
-           :Marking, :Firing, :Flux, :Gradient, :Delta,
            to: "self.class"
 
   attr_reader :type, # more like event_type, idea not matured yet
@@ -78,16 +95,16 @@ class YPetri::Net::DataSet < Hash
   # 
   def reconstruct at: (fail "No event given!"), **settings
     # settings may include marking clamps, marking, inital marking...
-    rec = interpolate( at )
+    record = interpolate( at )
     settings = settings().merge settings if settings()
     if timed? then
-      rec.reconstruct time: at, **settings
+      record.reconstruct time: at, **settings
     else
-      rec.reconstruct **settings
+      record.reconstruct **settings
     end
   end
 
-  # Interpolates the recording an the given point (event). Return value is the
+  # Interpolates the recording at the given point (event). Return value is the
   # Record class instance.
   # 
   def interpolate( event )
@@ -97,23 +114,24 @@ class YPetri::Net::DataSet < Hash
       timed? or raise TypeError, "Event #{event} not recorded! (%s)" %
         "simulation type: #{type.nil? ? 'nil' : type}"
       # (Remark: #floor, #ceiling supported by timed datasets only)
-      fe = floor( event )
-      fail "Event #{event} has no floor!" if fe.nil?
-      f = Matrix.column_vector record( fe )
-      ce = ceiling( event )
-      fail "Event #{event} has no ceiling!" if ce.nil?
-      c = Matrix.column_vector record( ce )
-      rslt = f + ( c - f ) / ( ce - fe ) * ( event - fe )
+      floor = floor( event )
+      fail "Event #{event} has no floor!" if floor.nil?
+      fl = Matrix.column_vector record( floor )
+      ceiling = ceiling( event )
+      fail "Event #{event} has no ceiling!" if ceiling.nil?
+      ce = Matrix.column_vector record( ceiling )
+      rslt = fl + ( ce - fl ) / ( ceiling - floor ) * ( event - floor )
       features.load( rslt.column_to_a )
     end
   end
+  alias at interpolate
 
   # Resamples the recording.
   # 
-  def resample **nn
-    time_range = nn.may_have( :time_range, syn!: :time ) ||
+  def resample **settings
+    time_range = settings.may_have( :time_range, syn!: :time ) ||
       events.first .. events.last
-    sampling = nn.must_have :sampling
+    sampling = settings.must_have :sampling
     t0, target_time = time_range.begin, time_range.end
     t = t0
     o = self.class.new type: type
@@ -137,165 +155,238 @@ class YPetri::Net::DataSet < Hash
 
   # Returns the data series for the specified features.
   # 
-  def series arg=nil
-    
-    return records.transpose if arg.nil?
-    reduce_features( State().features( arg ) ).series
+  def series array=nil
+    return records.transpose if array.nil?
+    reduce_features( net.State.Features array ).series
   end
 
   # Expects a hash of features (:marking (alias :state) of places, :firing
-  # of tS transitions, :delta of places and/or transitions) and returns the
-  # corresponding mapping of the recording.
+  # of tS transitions, :delta of places and/or transitions, :assignment of
+  # A transitions) and returns the corresponding mapping of the recording.
   # 
-  def reduce_features *args
-    Δt = if args.last.is_a? Hash then
-           args.last.may_have( :delta_time, syn!: :Δt )
-           args.last.delete( :delta_time )
-             .tap { args.delete_at( -1 ) if args.last.empty? }
-         end
-    reduced_features = net.State.features *args
-    rf_Record = reduced_features.Record
-    reduced_features.new_dataset( type: type ).tap { |dataset|
-      ( events >> records ).each_pair { |event, record|
-        absent_features = reduced_features - features()
-        if absent_features.empty? then # it is a subset
-          line = reduced_features.map { |feature| record.fetch feature }
-        else # it will require simulation reconstruction
-          sim = reconstruct at: event
-          if absent_features.any? { |f| f.timed? rescue false } then
-            fail ArgumentError, "Reconstruction of timed features requires " +
-              "the named arg :delta_time to be given!" unless Δt
-            line = reduced_features.map do |feature|
-              if absent_features.include? feature then
-                if ( feature.timed? rescue false ) then
-                  feature.extract_from( sim ).( Δt )
-                else
-                  feature.extract_from( sim )
-                end
-              else
-                record.fetch feature
-              end
-            end
-          else
-            line = reduced_features.map do |feat|
-              if absent_features.include? feat then
-                feat.extract_from( sim )
-              else record.fetch( feat ) end
-            end
-          end
-        end
-        dataset.update event => rf_Record.load( line )
-      }
-    }
+  def reduce_features array=nil, **named_args
+    delta_time_given = named_args.has? :delta_time, syn!: :Δt
+    Δt = named_args.delete :delta_time
+    ff = net.State.Features[ *array, **named_args ] # reduced feature set
+    absent = ff - features()         # features absent from the current set
+    present = ff - absent            # features present in the current set
+    timedness = true if absent.any? { |f| f.timed? rescue false }
+    fail ArgumentError, "Reconstruction of timed features requires Δt to be" +
+      "supplied!" unless delta_time_given if timedness
+    present_ii =
+      present.each_with_object( {} ) { |f, ꜧ| ꜧ[f] = features().index f }
+    ds = ff.DataSet.new type: type
+    if absent.empty? then # no reconstruction
+      ( events >> records ).each_with_object ds do |(event, record), dataset|
+        line = record.values_at *ff.map( &present_ii.method( :[] ) )
+        dataset.update event => ff.load( line )
+      end
+    else
+      ( events >> records ).each_with_object ds do |(event, record), dataset|
+        reconstructed_sim = reconstruct at: event
+        line = if timedness then
+                 ff.map { |f|
+                   i = present_ii[ f ]
+                   break record[ i ] if i
+                   f.extract_from( reconstructed_sim, Δt: Δt )
+                 }
+               else
+                 ff.map { |f|
+                   i = present_ii[ f ]
+                   break record[ i ] if i
+                   f.extract_from( reconstructed_sim, Δt: Δt )
+                 }
+               end
+        dataset.update event => ff.load( line )
+      end
+    end
   end
 
-  # Returns a subset of this dataset with only the specified marking features
-  # identified by the arguments retained. If no arguments are given, all the
-  # marking features from the receiver dataset are selected.
+  # Expects an array of marking feature identifiers, and returns a subset of
+  # this dataset with only the specified marking features retained.
   # 
-  def marking ids=nil
-    return reduce_features net.State.marking if ids.nil?
-    reduce_features marking: ids
+  def Marking array
+    reduce_features marking: array
   end
 
-  # Returns a subset of this dataset with only the specified firing features
-  # identified by the arguments retained. If no arguments are given, all the
-  # firing features from the receiver dataset are selected.
+  # Expects an arbitrary number of marking feature identifiers, and returns a
+  # subset of this dataset with only the specified marking features retained.
+  # If no arguments are given, all the marking features are assumed.
   # 
-  def firing *args
-    Δt = if args.last.is_a? Hash then
-           args.last.may_have( :delta_time, syn!: :Δt )
-           args.last.delete( :delta_time )
-             .tap { args.delete_at( -1 ) if args.last.empty? }
-         end
-    if Δt then
-      return reduce_features net.State.firing, delta_time: Δt if args.empty?
-      reduce_features firing: args.first, delta_time: Δt
-    else
-      return reduce_features net.State.firing if args.empty?
-      reduce_features firing: args.first
-    end
+  def marking *ids
+    return Marking net.State.Features.marking if ids.empty?
+    Marking ids
   end
 
-  # Returns a subset of this dataset with only the specified flux features
-  # identified by the arguments retained. If no arguments are given, all the
-  # flux features from the receiver dataset are selected.
+  # Expects an array of firing feature identifiers, and returns a subset of
+  # this dataset with only the specified firing features retained. Named
+  # arguments may include +:delta_time+, alias +:Δt+ (for firing of timed
+  # transitions).
+  # 
+  def Firing array, **named_args
+    reduce_features firing: array, **named_args
+  end
+
+  # Expects an arbitrary number of firing feature identifiers and returns
+  # a subset of this dataset with only the specified firing features retained.
+  # Named arguments may include +:delta_time+, alias +:Δt+ (for firing of
+  # timed transitions).
   # 
-  def flux ids=nil
-    return reduce_features net.State.flux if ids.nil?
-    reduce_features flux: ids
+  def firing *ids, **named_args
+    return Firing net.State.Features.firing, **named_args if ids.empty?
+    Firing ids, **named_args
+  end
+
+  # Expects an array of flux feature identifiers, and returns a subset of
+  # this dataset with only the specified flux features retained.
+  # 
+  def Flux array
+    reduce_features flux: array
+  end
+
+  # Expects an arbitrary number of flux feature identifiers, and returns
+  # a subset of this dataset, with only the specified flux features retained.
+  # If no aruments are given, full set of flux features is assumed.
+  # 
+  def flux *ids
+    return Flux net.State.Features.flux if ids.empty?
+    Flux ids
+  end
+
+  # Expects an array of gradient feature identifiers, optionally qualified by
+  # the +:transitions+ named argument, defaulting to all T transitions in the
+  # net.
+  # 
+  def Gradient array, transitions: nil
+    if transitions.nil? then
+      reduce_features gradient: array
+    else
+      reduce_features gradient: [ *array, transitions: transitions ]
+    end
   end
 
   # Returns a subset of this dataset with only the specified gradient features
   # identified by the arguments retained. If no arguments are given, all the
   # gradient features from the receiver dataset are selected.
   # 
-  def gradient *args
-    return reduce_features net.State.gradient if args.empty?
-    reduce_features gradient: args
+  def gradient *ids, transitions: nil
+    return Gradient net.State.Features.gradient, transitions: transitions if
+      ids.empty?
+    Gradient ids, transitions: transitions
   end
 
-  # Returns a subset of this dataset with only the specified delta features
-  # identified by the arguments retained. If no arguments are given, all the
-  # delta features from the receiver dataset are selected.
+  # Expects an array of delta feature identifiers, optionally qualified by
+  # the +:transitions+ named argument, defaulting to all the transitions in
+  # the net.
   # 
-  def delta *args
-    Δt = if args.last.is_a? Hash then
-           args.last.may_have( :delta_time, syn!: :Δt )
-           args.last.delete( :delta_time )
-             .tap { args.delete_at( -1 ) if args.last.empty? }
-         end
-    if Δt then
-      return reduce_features net.State.delta, delta_time: Δt if args.empty?
-      reduce_features delta: args, delta_time: Δt
+  def Delta array, transitions: nil, **named_args
+    if named_args.has? :delta_time, syn!: :Δt then
+      Δt = named_args.delete( :delta_time )
+      if transitions.nil? then
+        reduce_features delta: array, Δt: Δt
+      else
+        reduce_features delta: [ *array, transitions: transitions ], Δt: Δt
+      end
     else
-      return reduce_features net.State.delta if args.empty?
-      reduce_features delta: args
+      if transitions.nil? then
+        reduce_features delta: array
+      else
+        reduce_features delta: [ *array, transitions: transitions ]
+      end
     end
   end
 
+  # Expects an arbitrary number of ordered arguments identifying delta
+  # features, optionally qualified by the +:transitions+ named argument,
+  # defaulting to all the transitions in the net.
+  # 
+  def delta *ordered_args, transitions: nil, **named_args
+    return Delta( ordered_args, transitions: transitions, **named_args ) unless
+      ordered_args.empty?
+    return Delta( net.places, **named_args ) if transitions.nil?
+    Delta( net.places, transitions: transitions, **named_args )
+  end
+
+  def delta_timed *ordered_args, **named_args
+    delta *ordered_args, transitions: net.T_transitions, **named_args
+  end
+
+  def delta_timeless *ordered_args, **named_args
+    delta *ordered_args, transitions: net.t_transitions, **named_args
+  end
+
+  # Expects an array of assignment feature identifiers. Returns a subset of this
+  # dataset with only the specified assignment features retained.
+  # 
+  def Assignment array
+    reduce_features assignment: array
+  end
+
+  # Expects an arbitrary number of assignment feature identifiers as arguments,
+  # and returns a subset of this dataset with only the specified assignment
+  # features retained. If no arguments are given, all the assignment features
+  # are assumed.
+  # 
+  def assignment *ids
+    return reduce_features net.State.Features.assignment if args.empty?
+    reduce_features assignment: ids
+  end
+
   # Outputs the current recording in CSV format.
   # 
   def to_csv
-    map { |lbl, rec| [ lbl, *rec ].join ',' }.join "\n"
+    require 'csv'
+    [ ":event", *features.labels.map( &:to_s ) ].join( ',' ) + "\n" +
+      map { |lbl, rec| [ lbl, *rec ].join ',' }.join( "\n" )
   end
 
-  # Plots the dataset. Takes several optional arguments: The list of elements
-  # can be supplied as optional first ordered argument, which are then converted
-  # into features using +Net::State::Features.infer_from_elements+ method.
-  # Similarly, the features to exclude can be specifies as a list of elements
-  # (or a feature-specifying hash) supplied under +except:+ keyword. Otherwise,
-  # feature specification can be passed to the method as named arguments. If
-  # no feature specification is explicitly provided, it is assumed that all the
-  # features of this dataset are meant to be plotted.
+  # Plots the dataset. Takes several optional arguments: The list of nodes can be
+  # supplied as optional first ordered argument, which are then converted into
+  # features using +Net::State::Features.infer_from_nodes+ method. Similarly,
+  # the features to exclude can be specifies as a list of nodes (or a
+  # feature-specifying hash) supplied under +except:+ keyword. Otherwise, feature
+  # specification can be passed to the method as named arguments. If no feature
+  # specification is explicitly provided, it is assumed that all the features of
+  # this dataset are meant to be plotted.
   # 
-  def plot( element_ids=nil, time: nil, except: [], **nn )
+  def plot( nodes=nil, except: [], **named_args )
+    puts "Hello from plot!"
+    nn = named_args
     time = nn.may_have :time, syn!: :time_range
     events = events()
-    if element_ids.nil? then
-      nn_ff = nn.slice [ :marking, :flux, :firing, :gradient, :delta ]
-      ff = nn_ff.empty? ? features : net.State.features( nn_ff )
-    else
-      ff = net.State.Features.infer_from_elements( element_ids )
-    end
+    # Figure out features.
+    ff = if nodes.nil? then
+           nn_ff = nn.slice [ :marking, :flux, :firing,
+                              :gradient, :delta, :assignment ]
+           nn_ff.empty? ? features : net.State.Features( nn_ff )
+         else
+           net.State.Features.infer_from_nodes( nodes )
+         end
+    # Figure out the features not to plot ("except" features).
     xff = case except
-          when Array then net.State.Features.infer_from_elements( except )
-          when Hash then net.State.features( except )
+          when Array then net.State.Features.infer_from_nodes( except )
+          when Hash then net.State.Features( except )
           else
             fail TypeError, "Wrong type of :except argument: #{except.class}"
           end
+    # Subtract the "except" features from features to plot.
     ff -= xff
-    data_ss = series( ff )
-    x_range = if time.nil? then
+    # Convert the feature set into a set of data arrays.
+    data_arrays = series( ff )
+    # Figure out the x axis range for plotting.
+    x_range = if nn.has? :time then
+                if time.is_a? Range then
+                  "[#{time.begin}:#{time.end}]"
+                else
+                  "[-0:#{SY::Time.magnitude( time ).amount rescue time}]"
+                end
+              else
                 from = events.first || 0
-                to = events.last && events.last > from ? events.last :
-                  events.first + 1
+                to = if events.last and events.last > from then events.last
+                     else events.first + 1 end
                 "[#{from}:#{to}]"
-              elsif time.is_a? Range then
-                "[#{time.begin}:#{time.end}]"
-              else
-                "[-0:#{SY::Time.magnitude( time ).amount rescue time}]"
               end
+    # Invoke Gnuplot.
     Gnuplot.open do |gp|
       Gnuplot::Plot.new gp do |plot|
         plot.xrange x_range
@@ -307,10 +398,23 @@ class YPetri::Net::DataSet < Hash
         plot.title nn[:title] || "#{net} plot"
         plot.ylabel nn[:ylabel] || "Values"
         plot.xlabel nn[:xlabel] || "Time [s]"
-        ff.labels.zip( data_ss ).each do |label, data_array|
-          plot.data << Gnuplot::DataSet.new( [ events, data_array ] ) { |ds|
-            ds.with = "linespoints"
-            ds.title = label
+        ff.labels.zip( data_arrays ).each do |label, array|
+          # Replace NaN and Infinity with 0.0 and warn about it.
+          nan, inf = 0, 0
+          array = array.map { |v|
+            if v.to_f.infinite? then inf += 1; 0.0
+            elsif v.to_f.nan? then nan += 1; 0.0
+            else v end
+          }
+          # Warn.
+          nan = nan > 0 ? "#{nan} NaN values" : nil
+          inf = inf > 0 ? "#{inf} infinite values" : nil
+          msg = "Warning: column #{label} contains %s plotted as 0!"
+          warn msg % [ nan, inf ].compact.join( ' and ' ) if nan or inf
+          # Finally, plot.
+          plot.data << Gnuplot::DataSet.new( [ events, array ] ) { |set|
+            set.with = "linespoints"
+            set.title = label
           }
         end
       end