y_petri 2.0.15 → 2.1.3

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

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+class YPetri::Net::State
+  class Feature
+    # Marking of a Petri net place.
+    # 
+    class Marking < Feature
+      attr_reader :place
+
+      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 Marking then
+                                         hsh[ id.place ]
+                                       when ç.net.Place then
+                                         hsh[ id ] = ç.__new__( id )
+                                       else
+                                         hsh[ ç.net.place( 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 place
+        @place = net.place( place )
+      end
+
+      def extract_from arg, **nn
+        case arg
+        when YPetri::Simulation then
+          arg.m( [ place ] ).first
+        else
+          fail TypeError, "Argument type not supported!"
+        end
+      end
+
+      def to_s
+        place.name
+      end
+
+      def label
+        ":#{place.name}"
+      end
+    end # class Marking
+  end # class Feature
+end # YPetri::Net::State

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

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+class YPetri::Net::State
+  # A feature of a Petri net.
+  #
+  class Feature
+    require_relative 'feature/marking'
+    require_relative 'feature/firing'
+    require_relative 'feature/gradient'
+    require_relative 'feature/flux'
+    require_relative 'feature/delta'
+
+    class << self
+      def parametrize parameters
+        Class.new( self ).tap do |ç|
+          parameters.each_pair { |symbol, value|
+            ç.define_singleton_method symbol do value end
+          }
+          sç = ç.State
+          ç.instance_variable_set :@Marking, Marking.parametrize( State: sç )
+          ç.instance_variable_set :@Firing, Firing.parametrize( State: sç )
+          ç.instance_variable_set :@Gradient, Gradient.parametrize( State: sç )
+          ç.instance_variable_set :@Flux, Flux.parametrize( State: sç )
+          ç.instance_variable_set :@Delta, Delta.parametrize( State: sç )
+        end
+      end
+
+      delegate :net,
+               to: "State()"
+
+      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
+      end
+
+      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
+      end
+
+      def Gradient id=L!, transitions: net.T_tt
+        return @Gradient if id.local_object?
+        case id
+        when Gradient() then id
+        when Gradient then
+          Gradient().of( id.place, transitions: id.transitions )
+        else Gradient().of( id, transitions: transitions ) end # assume it's a place
+      end
+
+      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
+      end
+
+      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
+      end
+    end # class << self
+
+    delegate :net,
+             :State,
+             :Marking, :Firing, :Gradient, :Flux, :Delta,
+             to: "self.class"
+  end # class Feature
+end # YPetri::Net::State

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

@@ -0,0 +1,135 @@
+# encoding: utf-8
+
+class YPetri::Net::State
+  class Features
+    # Dataset is a collection of labeled state records.
+    # 
+    class Dataset < Hash
+      class << self
+        alias __new__ new
+
+        def new
+          __new__ do |hsh, missing|
+            case missing
+            when Float then nil
+            else hsh[ missing.to_f ] end
+          end
+        end
+      end
+
+      alias events keys
+      alias records values
+
+      delegate :features, to: "self.class"
+      delegate :net, to: :features
+      delegate :State, to: :net
+
+      # 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: event, **settings # settings include marking clampls
+        interpolate( event ).reconstruct **settings
+      end
+
+      # Interpolates the recording an the given point (event).
+      # 
+      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!"
+          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 features
+        rf = net.State.features( features )
+        rr_class = rf.Record
+        rf.new_dataset.tap do |ds|
+        ( events >> records ).each_pair { |event, record|
+            ds.update event => rr_class.load( rf.map { |f| record.fetch f } )
+          }
+        end
+      end
+
+      def marking *args
+        return reduce_features features.select { |f| f.is_a? YPetri::Net::State::Feature::Marking } if args.empty?
+        reduce_features marking: args.first
+      end
+
+      def firing *args
+        return reduce_features features.select { |f| f.is_a? YPetri::Net::State::Feature::Firing } if args.empty?
+        reduce_features firing: args.first
+      end
+
+      def flux *args
+        return reduce_features features.select { |f| f.is_a? YPetri::Net::State::Feature::Flux } if args.empty?
+        reduce_features flux: args.first
+      end
+
+      def gradient *args
+        return reduce_features features.select { |f| f.is_a? YPetri::Net::State::Feature::Gradient } if args.empty?
+        reduce_features gradient: args
+      end
+
+      def delta *args
+        return reduce_features features.select { |f| f.is_a? YPetri::Net::State::Feature::Delta } if args.empty?
+        reduce_features delta: args
+      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 # class Dataset
+  end # class Features
+end # YPetri::Simulation::State

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

@@ -0,0 +1,50 @@
+class YPetri::Net::State
+  class Features
+    # A collection of values for a given set of state features.
+    # 
+    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
+
+      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
+
+      # 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: {}
+        State.new self, marking_clamps: marking_clamps
+      end
+
+      delegate :reconstruct, to: :state
+    end # class Record
+  end # class Features
+end # YPetri::Net::State

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

@@ -0,0 +1,126 @@
+# 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
+
+      def delta places=net.pp, transitions: net.tt
+        transitions = net.tt( transitions )
+        new net.pp( places ).map { |p|
+          Delta( p, transitions: transitions )
+        }
+      end
+    end
+
+    delegate :State,
+             :net,
+             :Feature,
+             :feature,
+             :Marking,
+             :Firing,
+             :Gradient,
+             :Flux,
+             :Delta,
+             :load,
+             to: "self.class"
+
+    # Extracts the features from a given target
+    # 
+    def extract_from target, **nn
+      Record().new( map { |feature| feature.extract_from( target, **nn ) } )
+    end
+
+    # Constructs a new dataset from these features.
+    # 
+    def new_dataset
+      Dataset().new
+    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
+  end # class Features
+end # YPetri::Net::State

data/lib/y_petri/net/state.rb

@@ -0,0 +1,121 @@
+# encoding: utf-8
+
+class YPetri::Net
+  # Petri net state (marking of all its places).
+  #
+  class State < Array
+    require_relative 'state/feature'
+    require_relative 'state/features'
+
+    class << self
+      # Customization of the parametrize method for the State class: Its
+      # dependents Feature and Features (ie. feature set) are also parametrized.
+      # 
+      def parametrize net: (fail ArgumentError, "No owning net!")
+        Class.new( self ).tap do |subclass|
+          subclass.define_singleton_method :net do net end
+          subclass.param_class( { Feature: Feature,
+                                  Features: Features },
+                                with: { State: subclass } )
+        end
+      end
+
+      delegate :Marking,
+               :Firing,
+               :Gradient,
+               :Flux,
+               :Delta,
+               to: "Feature()"
+
+      alias __new__ new
+
+      # Revives a state from a record and a given set of marking clamps.
+      # 
+      def new record, 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
+
+        record = features( marking: net.pp - cc.keys ).load( record )
+
+        __new__ net.pp.map do |p|
+          begin; cc.fetch p; rescue IndexError
+            record.fetch Marking().of( p )
+          end
+        end
+      end
+
+      # Returns the feature identified by the argument.
+      # 
+      def feature id
+        case id
+        when Feature() then id
+        when Feature then id.class.new( id )
+        else
+          features( id ).tap do |ff|
+            ff.size == 1 or fail ArgumentError, "Argument #{id} must identify " +
+                                 "exactly 1 feature!"
+          end.first
+        end
+      end
+
+      # If the argument is an array of features, or another Features instance,
+      # a feature set based on this array is returned. But the real purpose of
+      # this method is to allow hash-type argument, with keys +:marking+,
+      # +:firing+, +:gradient+, +:flux+ and +:delta+, specifying the respective
+      # features. For +:marking+, an array of places (or Marking features) is
+      # expected. For +:firing+ and +:flux+, an array of transitions (or Firing
+      # / Flux features) is expected. For +:gradient+ and +:delta+, a hash value
+      # is expected, containing keys +:places+ and +:transitions+, specifying
+      # for which place set / transition set should gradient / delta features
+      # be constructed. More in detail, values supplied under keys +:marking+,
+      # +:firing+, +:gradient+, +:flux+ and +:delta+ are delegated to
+      # +Features.marking+, +Features.firing+, +Features.gradient+ and
+      # +Features.flux+ methods, and their results are joined into a single
+      # feature set.
+      # 
+      def features arg
+        case arg
+        when Features(), Array then Features().new( arg )
+        else # the real job of the method
+          marking = arg[:marking] || []
+          firing = arg[:firing] || [] # array of tS transitions
+          gradient = arg[:gradient] || [ [], transitions: [] ]
+          flux = arg[:flux] || [] # array of TS transitions
+          delta = arg[:delta] || [ [], transitions: [] ]
+          [ Features().marking( marking ),
+            Features().firing( firing ),
+            Features().gradient( *gradient ),
+            Features().flux( flux ),
+            Features().delta( *delta ) ].reduce :+
+        end
+      end
+
+      delegate :marking, :firing, :gradient, :flux, :delta, to: "Features()"
+    end
+
+    # For non-parametrized vesion of the class, the class instance variables
+    # hold the non-parametrized dependent classes.
+    # 
+    @Feature, @Features = Feature, Features
+
+    delegate :net,
+             :Feature,
+             :Features,
+             :features,
+             :marking, :firing, :gradient, :flux, :delta,
+             to: "self.class"
+
+    # Reconstructs a simulation from the current state instance, given marking
+    # clamps and other simulation settings.
+    # 
+    def reconstruct marking_clamps: {}, **settings
+      net.simulation marking: to_hash,
+                     marking_clamps: marking_clamps,
+                     **settings
+    end
+  end # class State
+end # YPetri::Net

data/lib/y_petri/net/timed.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+class YPetri::Net
+  # A mixin for timed nets, used by +#extend+ call during init.
+  # 
+  module Timed
+  end # module Timed
+end # class YPetri::Net

data/lib/y_petri/net/visualization.rb

@@ -19,10 +19,10 @@ class YPetri::Net
       ꜧ[tr] = γ.add_nodes tr.name.to_s,
                           shape: 'box',
                           fillcolor: if tr.assignment? then 'yellow'
-                                     elsif tr.basic_type == :SR then 'lightcyan'
+                                     elsif tr.type == :TS then 'lightcyan'
                                      else 'ghostwhite' end,
                           color: if tr.assignment? then 'goldenrod'
-                                 elsif tr.basic_type == :SR then 'cyan'
+                                 elsif tr.type == :TS then 'cyan'
                                  else 'grey' end,
                           style: 'filled'
     end
@@ -35,7 +35,7 @@ class YPetri::Net
         ( tr.domain - tr.codomain ).each { |pl|
           γ.add_edges tr_node, place_nodes[pl], color: 'grey', arrowhead: 'none'
         }
-      elsif tr.basic_type == :SR then
+      elsif tr.type == :TS then
         tr.codomain.each { |pl|
           if tr.stoichio[pl] > 0 then # producing arc
             γ.add_edges tr_node, place_nodes[pl], color: 'cyan'