y_petri 2.3.12 → 2.4.0

data/lib/y_petri/simulation/recorder.rb

@@ -66,6 +66,29 @@ class YPetri::Simulation::Recorder
   # Records the current state as a pair { sampling_event => system_state }.
   # 
   def sample! event
+    # TODO: Method #get_features( features )  seems to be just a little bit
+    # roundabout way of doing things, but not much more so than #send method,
+    # so it's still somehow OK. The question is, who should know what the
+    # features are and how they are extracted from various objects. Features?
+    # Or those objects?
+    #
+    # Ruby already has one mechanism of features, which are called properties
+    # of objects, and are presented by selector methods. Features reified as
+    # first-class objects are themselves responsible for their functional
+    # definitions. Features as first-class objects are related to Ted Nelson's
+    # ZZ dimensions. Current "Features" will have to be somehow merged (or
+    # at least, it will be necessary to consider their merger) with the ZZ
+    # structures once YNelson is finished to the point to which it should be
+    # finished.
+    #
+    # It seems to me that there is no use to decide in advance and in general
+    # who should hold the functional definition of every feature and every
+    # object. Sometimes it is convenient if the objects help to compute their
+    # common features (akin to patients being able to tell the doctor their
+    # name and family history), while in other cases, the features themselves
+    # should define the procedures needed to extract the values from the
+    # objects (akin to the doctor examining the patient).
+    # 
     record = simulation.get_features( features )
     recording[ event ] = record.dump( precision: SAMPLING_DECIMAL_PLACES )
   end

data/lib/y_petri/simulation/timed.rb

@@ -144,22 +144,22 @@ module YPetri::Simulation::Timed
   # options :just_before, :just_after and :exact, and tunes the simulation
   # behavior towards the end of the run.
   #
-  # just_before:     last step has normal size, simulation stops before or just
-  #                  on the target time
-  # just_after:      last step has normal size, simulation stops after or just
-  #                  on the target time_step
+  # stop_before:     last step has normal size, simulation stops before or just
+  #             on the target time
+  # stop_after:      last step has normal size, simulation stops after or just
+  #             on the target time_step
   # exact:           simulation stops exactly on the prescribed time, last step
   #                  is shortened if necessary
   #
   def run_upto( target_time, final_step: :exact )
     case final_step
-    when :before then
+    when :stop_before then
       step! while time + step <= target_time
     when :exact then
       step! while time + step < target_time
       step!( target_time - time )
       @time = target_time
-    when :after then
+    when :stop_after then
       step! while time < target_time
     else
       fail ArgumentError, "Unrecognized :final_step option: #{final_step}"
@@ -242,6 +242,24 @@ module YPetri::Simulation::Timed
         @initial_time, @target_time = time_range.begin, time_range.end
         @time_unit = initial_time.class.one
       else
+        # TODO: When using simulation after some time, I found this behavior
+        # surprising. I wanted to call simulation time: 100, expecting it
+        # to run until 100 (in the range 0..100). Instead, I see that it wants
+        # to run from 100 to infinity. While I understand how important it
+        # is to have a simple way to set the time of a newly constructed
+        # simulation to some value (for the purposes such as cloning of
+        # simulation, interpolation of simulations etc. -- actually, there
+        # is no really stateful net in YPetri at the moment, so Simulation
+        # class behaves somewhat as a stateful net...), not just me, but
+        # other users might expect :time argument to set final time with
+        # initial time being 0. I'm not gonna change it quite yet.
+        #
+        # The way to refactor it would be to first introduce "initial_time"
+        # parameter and make "time" parameter raise an error, and refactor
+        # the code until the tests pass. Then, to reintroduce "time"
+        # parameter with the new, more intuitive meaning. Interactive
+        # users can always modify time later (simulation.time = something).
+        # 
         @initial_time = settings[:time]
         @time_unit = initial_time.class.one
         @target_time = time_unit * Float::INFINITY
@@ -259,11 +277,86 @@ module YPetri::Simulation::Timed
     reset_time!
     @step = settings[:step] || time_unit
     @default_sampling = settings[:sampling] || step
-    @core = if @guarded then
-              YPetri::Core::Timed.new( simulation: self, method: method, guarded: true )
-            else
-              YPetri::Core::Timed.new( simulation: self, method: method, guarded: false )
-            end
+    if method == :runge_kutta then
+      # This is a bit irregular for now, but since the core has to behave
+      # differently (that is, more like a real simulation core), at least
+      # for the more advanced runge_kutta method, a core under a different
+      # instance variable will be constructed.
+      @rk_core = if @guarded then
+                   YPetri::Core::Timed.new( simulation: self, method: method, guarded: true )
+                 else
+                   YPetri::Core::Timed.new( simulation: self, method: method, guarded: false )
+                 end
+      singleton_class.class_exec do
+        attr_reader :rk_core
+        delegate :simulation_method,
+                 :firing_vector_tS,
+                 to: :rk_core
+        
+        # This method steps the simulation forward by the prescribed step. Simulation uses the core to perform the #step! method.
+        # 
+        def step! Δt=step()
+          # Pseudocode would be like this:
+          
+          # 1. set_state_and_time_of_core_to_the_current_simulation's_state_and_time
+          
+          # 2. explicitly tell the core the code by which to alert the sampler when necessary
+          # ie. when the state vector of the core progresses sufficiently for it to be
+          # interesting to the sampler
+
+          # 3. explicitly tell the core the code by which to update the simulation's state,
+          # and when should it be updated.
+          #
+          # (Note: This can be done in several ways. For example, one possibility is to
+          # update the simulation only after the core is finished computing. Another
+          # possibility is to have some other criterion to update the simulation more
+          # often in the course of the core's work. Since this is some sort of sampling
+          # job again, there is an option of actually delegating it to the sampler,
+          # which would thus get closer to its role of the interface.)
+          #
+          # (Note 2: It is actually more clear what the role of the core should be rather
+          # than what the simulation's role should be. The core should receive the initial
+          # instructions, a relatively simple method of what to do, and it should be
+          # specialized in doing its job fast. Secondly, it should receive the method for
+          # alerting the superiors: simulation and/or sampler. Thirdly, it should be told
+          # when to stop.)
+
+          # This should set the state of the rk_core to the marking vector of free
+          # places (#marking_vector method).
+          rk_core.marking_of_free_places.reset!( marking_vector )
+          sim, rec = self, recorder
+          rk_core.set_user_alert_closure do |mv_free| # marking vect. of free places
+            # TODO: This can be done differently. For example, the simulation can hand
+            # the core the function which, when handed a hash, will update the marking
+            # vector with the hash. This is actually quite similar, but there is some
+            # ugliness in it...
+            sim.m_vector.reset! mv_free.to_hash
+            sim.increment_time! Δt
+            Kernel.print '.'
+            rec.alert!
+          end
+
+          rk_core.step! Δt
+
+          # TODO: In the above lines, setting rec = recorder and then calling rec!.alert in
+          # the block is a bit weird. It would be nicer to use recorder.alert!, but maybe
+          # wise Ruby closure mechanism does not allow it...
+        end # def step!
+      end
+    else
+      @core = if @guarded then
+                YPetri::Core::Timed.new( simulation: self, method: method, guarded: true )
+              else
+                YPetri::Core::Timed.new( simulation: self, method: method, guarded: false )
+              end
+      singleton_class.class_exec do
+        attr_reader :core
+        delegate :simulation_method,
+                 :step!,
+                 :firing_vector_tS,
+                 to: :core
+      end
+    end
     @recorder = if features_to_record then
                   # we'll have to figure out features
                   ff = case features_to_record

data/lib/y_petri/simulation/transition_representation/types.rb

@@ -37,26 +37,18 @@ class YPetri::Simulation::TransitionRepresentation
 
     # Is this a TS transition?
     # 
-    def TS?
-      type == :TS
-    end
+    def TS?; type == :TS end
 
     # Is this a Ts transition?
     # 
-    def Ts?
-      type == :Ts
-    end
+    def Ts?; type == :Ts end
 
     # Is this a tS transition?
     # 
-    def tS?
-      type == :tS
-    end
+    def tS?; type == :tS end
 
     # Is this a ts transition?
     # 
-    def ts?
-      type == :ts
-    end
+    def ts?; type == :ts end
   end # module Types
 end # class YPetri::Simulation::TransitionRepresentation

data/lib/y_petri/simulation/transitions/access.rb

@@ -37,8 +37,8 @@ class YPetri::Simulation::Transitions
           A_tt: :A_transitions,
           S_Tt: :S_Transitions,
           S_tt: :S_transitions,
-          s_Tt: :S_Transitions,
-          s_tt: :S_transitions,
+          s_Tt: :s_Transitions,
+          s_tt: :s_transitions,
           T_Tt: :T_Transitions,
           T_tt: :T_transitions,
           t_Tt: :t_Transitions,
@@ -66,11 +66,11 @@ class YPetri::Simulation::Transitions
     # Transition instance identification.
     # 
     def transition( transition )
-      begin; Transition().instance( transition ); rescue NameError, TypeError
+      begin; TransitionPS().instance( transition ); rescue NameError, TypeError
         begin
           transition = net.transition( transition )
-          Transition().instances.find { |t_rep| t_rep.source == transition } || 
-            Transition().instance( transition.name )
+          TransitionPS().instances.find { |t_rep| t_rep.source == transition } || 
+            TransitionPS().instance( transition.name )
         rescue NameError, TypeError => msg
           fail TypeError, "Unknown transition instance: #{transition}! (#{msg})"
         end
@@ -85,7 +85,7 @@ class YPetri::Simulation::Transitions
     # not fil, but returns @Transitions parametrized subclass itself.
     # 
     def Transitions( array )
-      Transitions().load array.map &method( :transition )
+      TransitionsPS().load array.map &method( :transition )
     end
 
     # Without arguments, returns all the transition representations in the

data/lib/y_petri/simulation/transitions/types.rb

@@ -18,81 +18,71 @@ class YPetri::Simulation::Transitions
     # Subset of s type transitions, if any.
     # 
     def s
-      ( @Type_s ||= Class.new( self.class ).tap do |klass|
-          klass.class_exec { include Type_s }
-        end ).load subset( &:s? )
+      ( @Type_s ||= Class.new self.class do include Type_s end )
+        .load subset( &:s? )
     end
 
     # Subset of S type transitions, if any.
     # 
     def S
-      ( @Type_S ||= Class.new( self.class ).tap do |klass|
-          klass.class_exec { include Type_S }
-        end ).load subset( &:S? )
+      ( @Type_S ||= Class.new self.class do include Type_S end )
+        .load subset( &:S? )
     end
 
     # Subset of t type transitions, if any.
     # 
     def t
-      ( @Type_t ||= Class.new( self.class ).tap do |klass|
-          klass.class_exec { include Type_t }
-        end ).load subset( &:t? )
+      ( @Type_t ||= Class.new self.class do include Type_t end )
+        .load subset( &:t? )
     end
 
     # Subset of T type transitions, if any.
     # 
     def T
-      ( @Type_T ||= Class.new( self.class ).tap do |klass|
-          klass.class_exec { include Type_T }
-        end ).load subset( &:T? )
+      ( @Type_T ||= Class.new self.class do include Type_T end )
+        .load subset( &:T? )
     end
 
     # Subset of ts type transitions, if any.
     # 
     def ts
-      ( @Type_ts ||= Class.new( self.class ).tap do |klass|
-          klass.class_exec { include Type_ts }
-        end ).load subset( &:ts? )
+      ( @Type_ts ||= Class.new self.class do include Type_ts end )
+        .load subset( &:ts? )
     end
 
     # Subset of tS type transitions, if any.
     # 
     def tS
-      ( @Type_tS ||= Class.new( self.class ).tap do |klass|
-          klass.class_exec { include Type_tS }
-        end ).load subset( &:tS? )
+      ( @Type_tS ||= Class.new self.class do include Type_tS end )
+        .load subset( &:tS? )
     end
 
     # Subset of Ts type transitions, if any.
     # 
     def Ts
-      ( @Type_Ts ||= Class.new( self.class ).tap do |klass|
-          klass.class_exec { include Type_Ts }
-        end ).load subset( &:Ts? )
+      ( @Type_Ts ||= Class.new self.class do include Type_Ts end )
+        .load subset( &:Ts? )
     end
 
     # Subset of TS type transitions, if any.
     # 
     def TS
-      ( @Type_TS ||= Class.new( self.class ).tap do |klass|
-          klass.class_exec { include Type_TS }
-        end ).load subset( &:TS? )
+      ( @Type_TS ||= Class.new self.class do include Type_TS end )
+        .load subset( &:TS? )
     end
 
     # Subset of A type transitions, if any.
     # 
     def A
-      ( @Type_A ||= Class.new( self.class ).tap do |klass|
-          klass.class_exec { include Type_A }
-        end ).load subset( &:A? )
+      ( @Type_A ||= Class.new self.class do include Type_A end )
+        .load subset( &:A? )
     end
 
     # Subset of a type transitions, if any.
     # 
     def a
-      ( @Type_a ||= Class.new( self.class ).tap do |klass|
-          klass.class_exec { include Type_a }
-        end ).load subset( &:a? )
+      ( @Type_a ||= Class.new self.class do include Type_a end )
+        .load subset( &:a? )
     end
   end # Types
 end # class YPetri::Simulation::Transitions

data/lib/y_petri/simulation/transitions.rb

@@ -13,7 +13,9 @@ class YPetri::Simulation
       t = begin; net.transition( transition ); rescue NameError, TypeError
             return super transition( transition )
           end
-      super t.name ? Transition().new( t, name: t.name ) : Transition().new( t )
+      super t.name ?
+              TransitionPS().new( t, name: t.name ) :
+              TransitionTS().new( t )
     end
   end # class Transitions
 end # class YPetri::Simulation::Transitions

data/lib/y_petri/simulation.rb

@@ -53,8 +53,7 @@ class YPetri::Simulation
   end
 
   # Parametrized subclasses.
-  attr_reader :core,
-              :recorder,
+  attr_reader :recorder, # :core,
               :guarded,
               :tS_stoichiometry_matrix,
               :TS_stoichiometry_matrix,
@@ -71,15 +70,15 @@ class YPetri::Simulation
 
   delegate :net, to: "self.class"
 
+  delegate :recording,
+           :back!,
+           to: :recorder
+
   delegate :simulation_method,
            :step!,
            :firing_vector_tS,
            to: :core
 
-  delegate :recording,
-           :back!,
-           to: :recorder
-
   alias r recording
 
   delegate :plot,
@@ -136,19 +135,19 @@ class YPetri::Simulation
                  initial_marking: {},
                  marking: nil,
                  **settings
-    param_class!( { Place: PlaceRepresentation, # parametrized subclasses
-                    Places: Places,
-                    Transition: TransitionRepresentation,
-                    Transitions: Transitions,
-                    Nodes: Nodes,
+    param_class!( { PlacePS: PlaceRepresentation, # PS = parametrized subclass
+                    PlacesPS: Places,
+                    TransitionPS: TransitionRepresentation,
+                    TransitionsPS: Transitions,
+                    NodesPS: Nodes,
                     PlaceMapping: PlaceMapping,
                     InitialMarking: InitialMarking,
                     MarkingClamps: MarkingClamps,
                     MarkingVector: MarkingVector },
                   with: { simulation: self } )
-    [ Place(), Transition() ].each &:namespace! # each serves as its namespace
+    [ PlacePS(), TransitionPS() ].each &:namespace! # each serves as its namespace
     @guarded = guarded # TODO: Not operable as of now.
-    @places = Places().load( net.places )
+    @places = PlacesPS().load( net.places )
     @marking_clamps = MarkingClamps().load( marking_clamps )
     @initial_marking = if marking then
                          m = PlaceMapping().load( marking )
@@ -170,7 +169,7 @@ class YPetri::Simulation
     # Initialize the marking vector.
     @m_vector = MarkingVector().zero
     # Set up the collection of transitions.
-    @transitions = Transitions().load( net.transitions )
+    @transitions = TransitionsPS().load( net.transitions )
     # Set up stoichiometry matrices relative to free places.
     @tS_stoichiometry_matrix = transitions.tS.stoichiometry_matrix
     @TS_stoichiometry_matrix = transitions.TS.stoichiometry_matrix
@@ -250,6 +249,10 @@ class YPetri::Simulation
     places.zip( ary ).each { |pl, proposed_m| pl.guard.( proposed_m ) }
   end
 
+  # TODO: The method below does nothing except that it delegates extraction
+  # of a set of features to Features class. Features understood in this way
+  # are similar to ZZ dimensions.
+
   # Extract a prescribed set of features.
   # 
   def get_features *args

data/lib/y_petri/version.rb

@@ -1,4 +1,4 @@
 module YPetri
-  VERSION = "2.3.12"
+  VERSION = "2.4.0"
   DEBUG = false
 end

data/lib/y_petri/world.rb

@@ -4,7 +4,7 @@ require_relative 'world/dependency'
 require_relative 'world/petri_net_aspect'
 require_relative 'world/simulation_aspect'
 
-# Represents YPetri workspace, but "world" is shorter. Its instance holds
+# Represents YPetri workspace ("World" is shorter). Its instance holds
 # places, transitions, nets and other assets needed to perform the tasks
 # of system specification and simulation (simulation settings, place clamps,
 # initial markings etc.). Provides basic methods to do just what is necessary.