y_petri 2.1.3 → 2.1.6

data/lib/y_petri/net/data_set.rb

@@ -0,0 +1,238 @@
+# encoding: utf-8
+
+# Dataset is a collection of labeled state records.
+# 
+class YPetri::Net::DataSet < Hash
+  class << self
+    alias __new__ new
+
+    def new type: nil
+      __new__ do |hsh, missing|
+        case missing
+        when Float then nil
+        else hsh[ missing.to_f ] end
+      end.tap { |inst|
+        inst.instance_variable_set :@type, type
+      }
+    end
+
+    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
+
+  # Type of the dataset.
+  # 
+  def timed?
+    type == :timed
+  end
+
+  # Returns a Record instance corresponding to the given recorded event.
+  # 
+  def record( event )
+    features.load( fetch event )
+  end
+
+  # Revives records from values.
+  # 
+  def records
+    values.map { |value| features.Record.new( value ) }
+  end
+
+  # Recreates the simulation at a given event label.
+  # 
+  def reconstruct event: (fail "No event given!"),
+    **settings # settings include marking clamps
+    rec = interpolate( event )
+    if timed? then
+      rec.reconstruct time: event, **settings
+    else
+      rec.reconstruct **settings
+    end
+  end
+
+  # Interpolates the recording an the given point (event). Return value is the
+  # Record class instance.
+  # 
+  def interpolate( event )
+    # TODO: This whole interpolation thing is unfinished.
+    begin
+      record( event )
+    rescue KeyError => msg
+      timed? or raise TypeError, "Event #{event} does not have a record! (%s)" %
+        "simulation type: #{type.nil? ? 'nil' : type}"
+      f_time, floor = floor( event ) # timed datasets support floor, ceiling
+      c_time, ceiling = ceiling( time )
+      floor + ( ceiling - floor ) / ( c_time - f_time ) * ( time - f_time )
+    end
+  end
+
+  # Returns the data series for the specified features.
+  # 
+  def series arg=nil
+    return records.transpose if arg.nil?
+    reduce_features( State().features( arg ) ).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.
+  # 
+  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 do |dataset|
+      ( events >> records ).each_pair do |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 event: 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 |feature|
+              if absent_features.include? feature then
+                feature.extract_from( sim )
+              else
+                record.fetch feature
+              end
+            end
+          end
+        end
+        dataset.update event => rf_Record.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.
+  # 
+  def marking ids=nil
+    return reduce_features net.State.marking if ids.nil?
+    reduce_features marking: ids
+  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.
+  # 
+  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
+  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.
+  # 
+  def flux ids=nil
+    return reduce_features net.State.flux if ids.nil?
+    reduce_features flux: ids
+  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
+  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.
+  # 
+  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
+    else
+      return reduce_features net.State.delta if args.empty?
+      reduce_features delta: args
+    end      
+  end
+
+  # Outputs the current recording in CSV format.
+  # 
+  def to_csv
+    map { |lbl, rec| [ lbl, *rec ].join ',' }.join "\n"
+  end
+
+  # Plots the dataset.
+  # 
+  def plot( time: nil, **nn )
+    events = events()
+    data_ss = series
+    x_range = if time.is_a? Range then
+                "[#{time.begin}:#{time.end}]"
+              else
+                "[-0:#{SY::Time.magnitude( time ).amount rescue time}]"
+              end
+    
+    Gnuplot.open do |gp|
+      Gnuplot::Plot.new gp do |plot|
+        plot.xrange x_range
+        plot.title nn[:title] || "#{net} plot"
+        plot.ylabel nn[:ylabel] || "Values"
+        plot.xlabel nn[:xlabel] || "Time [s]"
+        
+        features.labels.zip( data_ss )
+          .each { |label, data_array|
+          plot.data << Gnuplot::DataSet.new( [ events, data_array ] ) { |ds|
+            ds.with = "linespoints"
+            ds.title = label
+          }
+        }
+      end
+    end
+  end
+end # YPetri::Net::Dataset

data/lib/y_petri/net/own_state.rb

@@ -0,0 +1,63 @@
+# 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.
+  # 
+  def state
+    State().new( marking )
+  end
+
+  # If no argument is supplied, the method returns the array of the markings
+  # owned by the net's places. If an array of place identifiers is supplied,
+  # the return value is the array of the markings owned by those places.
+  #
+  def marking place_ids=nil
+    return marking( pp ) if place_ids.nil?
+    place_ids.map { |id| place( id ).marking }
+  end
+
+  # Takes an array of tS transition identifiers as an optional argument, and
+  # returns the array of their firing under current net state. If no argument
+  # is supplied, the net is required to contain no TS transtions, and the
+  # method returns the array of firing of all net's tS transitions.
+  #
+  def firing transition_ids=nil
+    if transition_ids.nil? then
+      fail TypeError, "Method #firing with no arguments is ambiguous for " +
+        "nets with TS transitions!" if timed?
+      firing( tS_tt )
+    else
+      transition_ids.map { |id| tS_transition( id ).firing }
+    end
+  end
+
+  # Takes an array of TS transition identifiers as an optional argument, and
+  # returns the array of their fluxes under current net state. If no argument
+  # is supplied, the array of fluxes of all net's TS transitions is returned.
+  #
+  def flux transition_ids=nil
+    return flux TS_tt() if transition_ids.nil?
+    transition_ids.map { |id| TS_transition( id ).flux }
+  end
+
+  # Takes an array of place identifiers, and a named argument +:transitions+,
+  # and returns the array of the place gradient contribution by the indicated
+  # transitions. The +:transitions+ argument defaults to all the transitions,
+  # place identifiers default to all the places. The net must be timed.
+  # 
+  #
+  def gradient place_ids=pp, transitions: tt
+    fail NotImplementedError
+  end
+
+  # Takes an array of place identifier, and a named argument +:transitions+,
+  # and returns the array of the place delta contribution by the indicated
+  # transitions.
+  #
+  def delta place_ids=nil, transitions: tt
+    fail NotImplementedError
+  end
+end # module YPetri::Net::OwnState

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

@@ -1,88 +1,115 @@
 # encoding: utf-8
 
-class YPetri::Net::State
-  class Feature
-    # Change of a Petri net place caused by a certain set of transitions.
-    # 
-    class Delta < Feature
-      attr_reader :place, :transitions, :step
+# 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
 
-      class << self
-        def parametrize *args
-          Class.instance_method( :parametrize ).bind( self ).( *args ).tap do |ç|
-            # First, prepare the hash of instances.
-            hsh = Hash.new do |ꜧ, id|
-              puts "Delta received:"
-              p id
-              puts "of class #{id.class}, with ancestors:"
-              p id.class.ancestors
-              if id.is_a? Delta then
-                ꜧ[ [ id.place, transitions: id.transitions.sort( &:object_id ) ] ]
+  class << self
+    def parametrize *args
+      Class.instance_method( :parametrize ).bind( self ).( *args ).tap do |ç|
+        # First, prepare the hash of instances.
+        hsh = Hash.new do |ꜧ, id|
+          if id.is_a? self then # missing key "id" is a Delta instance
+            ꜧ[ [ id.place, transitions: id.transitions.sort( &: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 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
-                puts "here"
-                p id
-                puts "id size is #{id.size}"
-                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 }
-                  if tt == tt.sort then
-                    ꜧ[ id ] = ç.__new__( *id )
-                  else
-                    ꜧ[ [ p, transitions: tt.sort ] ]
-                  end
-                else
-                  ꜧ[ [ ç.net.place( p ), transitions: ç.net.transitions( tt ) ] ]
-                end
+                ꜧ[ [ p, transitions: tt.sort ] ]
               end
+            else # convert place and transition ids to places and transitions
+              ꜧ[ [ ç.net.place( p ), transitions: ç.net.transitions( tt ) ] ]
             end
-            # And then, assign it to the :@instances variable.
-            ç.instance_variable_set :@instances, hsh
           end
         end
+        # And then, assign it to the :@instances variable.
+        ç.instance_variable_set :@instances, hsh
+      end
+    end
 
-        attr_reader :instances
+    attr_reader :instances
 
-        alias __new__ new
+    alias __new__ new
 
-        def new *args
-          return instances[ *args ] if args.size == 1
-          instances[ args ]
-        end
+    # Timed delta feature constructor. Takes a place, and an array of timed
+    # transition identifiers supplied as +:transitions: parameter.
+    # 
+    def timed place, transitions: net.T_tt
+      __new__( place, transitions: net.T_tt( transitions ) )
+        .tap { |inst| inst.instance_variable_set :@timed, true }
+    end
 
-        def of *args
-          new *args
-        end
-      end
+    # Timeless delta feature constructor. Takes a place, and an array of
+    # timeless transition identifiers as +:transitions: parameter.
+    # 
+    def timeless place, transitions: net.t_tt
+      __new__( place, transitions: net.t_tt( transitions ) )
+        .tap { |inst| inst.instance_variable_set :@timed, false }
+    end
 
-      def initialize place, transitions: net.tt
-        @place = net.place( place )
-        @transitions = net.transitions( transitions )
-      end
+    # Constructor #new is redefined to use instance cache.
+    # 
+    def new *args
+      return instances[ *args ] if args.size == 1
+      instances[ args ]
+    end
+    alias of new
+  end
 
-      def extract_from arg, **nn
-        # **nn is here because of timed / timeless possibility, where
-        # **nn would contain :step named argument.
-        case arg
-        when YPetri::Simulation then
-          _T = arg.send( :T_transitions, transitions )
-          _t = arg.send( :t_transitions, transitions )
-          if _T.empty? then _t.delta.fetch( place ) else # time step is required
-            _t.delta.fetch( place ) + _T.delta( nn[:step] ).fetch( place )
-          end
-        else
-          fail TypeError, "Argument type not supported!"
-        end
-      end
+  def initialize place, transitions: net.tt
+    @place = net.place( place )
+    @transitions = net.transitions( transitions )
+  end
 
-      def to_s
-        place.name
+  # Extracts the value of this feature from the supplied target
+  # (eg. a simulation).
+  # 
+  def extract_from arg, **nn
+    # **nn is here because of timed / timeless possibility, where
+    # **nn would contain :step named argument.
+    case arg
+    when YPetri::Simulation then
+      if timed? then
+        tt = arg.send( :T_transitions, transitions )
+        -> Δt { tt.delta( Δt ).fetch( place ) }
+      else
+        arg.send( :t_transitions, transitions ).delta.fetch( place )
       end
+    else
+      fail TypeError, "Argument type not supported!"
+    end
+  end
 
-      def label
-        "∂:#{place.name}:#{transitions.size}tt"
-      end
-    end # class Delta
-  end # class Feature
-end # YPetri::Net::State
+  # Is the delta feature timed?
+  # 
+  def timed?
+    @timed
+  end
+
+  # Opposite of +#timed?+.
+  # 
+  def timeless?
+    ! timed?
+  end
+
+  def to_s
+    place.name
+  end
+
+  def label
+    "∂:#{place.name}:#{transitions.size}tt"
+  end
+end # class YPetri::Net::State::Feature::Delta

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

@@ -1,57 +1,54 @@
 # encoding: utf-8
-class YPetri::Net::State
-  class Feature
-    # Firing of a Petri net tS transition.
-    # 
-    class Firing < Feature
-      attr_reader :transition
-
-      class << self
-        def parametrize *args
-          Class.instance_method( :parametrize ).bind( self ).( *args ).tap do |ç|
-            ç.instance_variable_set( :@instances,
-                                     Hash.new do |hsh, id|
-                                       case id
-                                       when Firing then
-                                         hsh[ id.transition ]
-                                       when ç.net.Transition then
-                                         hsh[ id ] = ç.__new__( id )
-                                       else
-                                         hsh[ ç.net.transition( id ) ]
-                                       end
-                                     end )
-          end
-        end
-
-        attr_reader :instances
-
-        alias __new__ new
-
-        def new id
-          instances[ id ]
-        end
-
-        def of id
-          new id
-        end
-      end
-
-      def initialize transition
-        @transition = net.transition( transition )
-      end
-
-      def extract_from arg, **nn
-        case arg
-        when YPetri::Simulation then
-          arg.send( :tS_transitions, [ transition ] ).firing.first
-        else
-          fail TypeError, "Argument type not supported!"
-        end
-      end
 
-      def label
-        "f:#{transition.name}"
+# Firing of a Petri net tS transition.
+# 
+class YPetri::Net::State::Feature::Firing < YPetri::Net::State::Feature
+  attr_reader :transition
+
+  class << self
+    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
+                                     hsh[ id ] = ç.__new__( id )
+                                   else
+                                     hsh[ ç.net.transition( id ) ]
+                                   end
+                                 end )
       end
-    end # class Firing
-  end # class Feature
-end # YPetri::Net::State
+    end
+
+    attr_reader :instances
+
+    alias __new__ new
+
+    def new id
+      instances[ id ]
+    end
+
+    def of id
+      new id
+    end
+  end
+
+  def initialize transition
+    @transition = net.transition( transition )
+  end
+
+  def extract_from arg, **nn
+    case arg
+    when YPetri::Simulation then
+      arg.send( :tS_transitions, [ transition ] ).firing.first
+    else
+      fail TypeError, "Argument type not supported!"
+    end
+  end
+
+  def label
+    "f:#{transition.name}"
+  end
+end # YPetri::Net::State::Feature::Firing