y_petri 2.2.4 → 2.3.2

data/lib/y_petri/simulation/places.rb

@@ -1,25 +1,32 @@
-#encoding: utf-8
-
-require_relative 'places/types'
-require_relative 'places/free'
-require_relative 'places/clamped'
+# encoding: utf-8
 
 # Place collection for YPetri::Simulation.
 #
-class YPetri::Simulation::Places
+class YPetri::Simulation::Places < YPetri::Simulation::Nodes
+
+  require_relative 'places/types'
+  require_relative 'places/free'
+  require_relative 'places/clamped'
+
   ★ Types
 
   # Pushes a place to the collection.
   # 
   def push place
-    p = begin
-          net.place( place )
-        rescue NameError, TypeError
+    p = begin; net.place( place ); rescue NameError, TypeError
           return super place( place )
         end
     super p.name ? Place().new( p, name: p.name ) : Place().new( p )
   end
 
+  # Marking of the place collection in the current simulation.
+  # 
+  def marking
+    simulation.M self
+  end
+
+  private
+
   # Ensures that all the places that are not clamped have their initial marking
   # set. Optional argument :use_default_marking is set to _true_ by default, in
   # which case own default marking of the source places is used if it was not
@@ -27,15 +34,13 @@ class YPetri::Simulation::Places
   # of places with missing initial marking simply raises errors.
   # 
   def complete_initial_marking( use_default_marking: true )
-    missing = reject { |pl| ( free + clamped ).include? pl }
-    unless use_default_marking
-      fail TypeError, "All places must have default marking or clamp!" unless
-        missing.empty?
-    end
-    missing.each { |pl|
-      dflt = pl.source.default_marking
-      fail TypeError, "Source's default marking is missing (nil)!" if dflt.nil?
-      simulation.send :set_initial_marking, { of: pl, to: dflt }
+    offenders = reject { |place| ( free + clamped ).include? place }
+    fail TypeError, "All places must have default marking or clamp!" unless
+      use_default_marking unless offenders.empty?
+    offenders.each { |place|
+      dm = place.source.default_marking
+      fail TypeError, "#{place.source} has no default marking!" if dm.nil?
+      simulation.send( :set_initial_marking, place, to: dm )
     }
   end
 end # class YPetri::Simulation::Places

data/lib/y_petri/simulation/recorder.rb

@@ -1,8 +1,8 @@
 # encoding: utf-8
 
 # A machine that receives alerts during simulation and records a recording
-# according to its implementation. Alerts are received via +#alert+ method.
-# The recording bein recorded is stored in @recording instance variable.
+# according to its implementation. Alerts are received via +#alert!+ method.
+# The recording being recorded is stored in +@recording+ instance variable.
 # This can be reset by +#reset!+ method, which also accepts arguments to
 # change the recorder settings and/or insert another recording.
 #
@@ -14,45 +14,50 @@ class YPetri::Simulation::Recorder
   attr_reader :features
 
   def recording
-    @recording.tap { |ds|
-      ds.instance_variable_set :@settings, simulation.settings( true )
+    @recording.tap { |dataset|
+      dataset.instance_variable_set :@settings, simulation.settings( true )
     }
   end
 
-  delegate :simulation, to: "self.class"
-  delegate :reconstruct, :reduce, to: :recording
+  delegate :simulation,
+           to: "self.class"
+
+  delegate :reconstruct,
+           :reduce,
+           to: :recording
 
   # Initializes the recorder. Takes 2 arguments: +:features+ expecting the
   # feature set to record during simulation, and +:recording+, expecting the
   # initial state of the recording.
   # 
-  def initialize features: net.State.marking( free_pp ),
+  def initialize features: net.State.Features.Marking( free_pp ),
                  recording: nil,
                  **nn
-    @features = net.State.features( features )
-    if recording then reset! recording: recording else reset! end
+    @features = net.State.Features( features )
+    recording ? reset!( recording: recording ) : reset!
   end
 
-  # Construct a new recording based on the parametrized class Recording().
+  # Construct a new recording based on the Recording() class.
   # 
   def new_recording
-    features.new_dataset
+    @features.DataSet.new
   end
 
-  # Assigns to @recording a new Dataset instance. Without arguments, the new
-  # recording is empty. With +:recording+ named argument supplied, the new
-  # recording is filled with the prescribed contents.
+  # Assigns to +@recording+ a new +DataSet+ instance. If no arguments are
+  # supplied to this method, the new recording will stay empty. A recording
+  # can be optionally supplied via +:recording+ named argument.
   # 
-  def reset! **nn
-    @features = net.State.features( nn[:features] || @features )
+  def reset! features: nil, recording: nil, **named_args
+    @features = net.State.Features( features ) if features
     @recording = new_recording
-    @recording.update Hash[ nn[:recording] ] if nn[:recording]
+    @recording.update Hash[ recording ] if recording
+    return self
   end
 
   # Hook to be called by simulators whenever there is a state change. The
   # decision to sample is then the business of the recorder.
   # 
-  def alert
+  def alert!
     sample! # vanilla recorder samples at every occasion
   end
 

data/lib/y_petri/simulation/timed/recorder.rb

@@ -6,6 +6,7 @@ module YPetri::Simulation::Timed
 
     attr_reader :next_time
     attr_accessor :sampling
+
     delegate :time,
              :default_sampling,
              to: :simulation
@@ -13,32 +14,29 @@ module YPetri::Simulation::Timed
     # Apart from the vanilla version arguments, timed recorder takes +:sampling+
     # argument.
     # 
-    def initialize sampling: default_sampling, next_time: time, **nn
+    def initialize( sampling: default_sampling, next_time: time, **named_args )
       super
-      @sampling = sampling
-      @next_time = next_time
+      @sampling, @next_time = sampling, next_time
     end
 
     # Construct a new recording based on +features+.
     # 
     def new_recording
-      features.new_dataset type: :timed
+      features.DataSet.new type: :timed
     end
 
     # Like +YPetri::Simulation::Recorder#reset+, but allowing for an additional
     # named argument +:next_time+ that sets the next sampling time, and
     # +:sampling:, resetting the sampling period.
     # 
-    def reset! sampling: default_sampling, next_time: time, **nn
-      super
-      @sampling = sampling
-      @next_time = next_time
+    def reset! sampling: default_sampling, next_time: time, **named_args
+      super.tap{ @sampling, @next_time = sampling, next_time }
     end
 
-    # Hook to be called by simulators whenever the state changes (every time
-    # that simulation +time+ is incremented).
+    # To be called by simulators whenever the state changes (every time that
+    # simulation +time+ is incremented).
     # 
-    def alert
+    def alert!
       t = time.round( 9 )
       t2 = next_time.round( 9 )
       if t >= t2 then # it's time to sample
@@ -47,6 +45,16 @@ module YPetri::Simulation::Timed
       end
     end
 
+    # Steps the simulation back. This prototype version of the method simply
+    # reconstructs a new simulation at a given time (1 simulation step by
+    # default) before the current time.
+    # 
+    def back! by=simulation.step
+      time = simulation.time - by
+      simulation.recording.reconstruct( at: simulation.recording.floor( time ) )
+        .tap { |sim| sim.run! upto: time }
+    end
+
     private
 
     # Records the current state as a pair { sampling_time => system_state }.

data/lib/y_petri/simulation/timed.rb

@@ -23,6 +23,39 @@ module YPetri::Simulation::Timed
   alias starting_time initial_time
   alias ending_time target_time
 
+  attr_accessor :step, :target_time
+
+  # Explicit alias for +#step=+ method. Deprecated, use +#step=+ instead.
+  # 
+  def set_step n
+    step=( n )
+  end
+  alias set_step_size set_step
+
+  # Explicit alias for +#target_time=+ method. Deprecated, use +#target_time=+
+  # instead.
+  # 
+  def set_time target_time
+    target_time=( target_time )
+  end
+  alias set_target_time set_time
+
+  delegate :sampling,
+           :sampling=, to: :recorder
+
+  # Sets sampling of the simulation's data recorder.
+  # 
+  def set_sampling sampling
+    recorder.sampling = sampling
+  end 
+
+  # Changing the simulation method on the fly not supported.
+  # 
+  def set_simulation_method
+    fail NotImplementedError,
+         "Changing simulation method on the fly not supported!"
+  end
+
   delegate :flux_vector_TS,
            :gradient_TS,
            :gradient_Ts,
@@ -30,33 +63,52 @@ module YPetri::Simulation::Timed
            :flux_vector,
            to: :core
 
-  delegate :sampling, to: :recorder
-
-  # Returns the flux of the indicated TS transitions (all TS transitions,
-  # if no argument is given).
+  # Expects a single array of TS transitions or transition ids and returns an
+  # array of their fluxes under current marking.
   #
-  def flux ids_of_TS_transitions=nil
+  def Fluxes( array )
     tt = TS_transitions()
-    return flux tt if ids_of_TS_transitions.nil?
-    TS_transitions( ids_of_TS_transitions ).map { |t|
-      flux_vector.column_to_a.fetch tt.index( t )
-    }
+    TS_Transitions( array )
+      .map { |t| flux_vector.column_to_a.fetch tt.index( t ) }
+  end
+
+  # Expects an arbitrary number of arguments identifying TS transitions, and
+  # retuns an array of their fluxes. Returns fluxes of all the TS transitions
+  # if no argument is given.
+  #
+  def fluxes( *transitions )
+    return Fluxes TS_transitions() if transitions.empty?
+    Fluxes( transitions )
+  end
+  alias flux fluxes
+
+  # Fluxes of the indicated TS transitions. Expects a single array argument,
+  # and returns a hash with transition names as keys.
+  # 
+  def T_fluxes( array )
+    TS_Transitions( array ).names( true ) >> Fluxes( array )
   end
+  alias t_Fluxes T_fluxes
 
-  # Flux of the indicated TS transitions (as hash with transition names as keys).
+  # Fluxes of the indicated TS transitions. Expects an arbitrary number of
+  # TS transitions or their ids, returns a hash with transition names as keys.
   # 
-  def t_flux ids=nil
-    TS_transitions( ids ).names( true ) >> flux( ids )
+  def t_fluxes( *transitions )
+    return T_fluxes TS_transitions() if transitions.empty?
+    T_fluxes( transitions )
   end
+  alias t_flux t_fluxes
 
-  # Pretty prints flux of the indicated TS transitions as hash with transition
+  # Pretty prints flux of the indicated TS transitions as a hash with transition
   # names as keys. Takes optional list of transition ids (first ordered arg.),
-  # and optional 2 named arguments (+:gap+ and +:precision), as in
+  # and optional 2 named arguments (+:gap+ and +:precision+), as in
   # +#pretty_print_numeric_values+.
   # 
-  def pflux ids=nil, gap: 0, precision: 4
-    t_flux( ids ).pretty_print_numeric_values( gap: gap, precision: precision )
+  def pflux( *transitions, gap: 0, precision: 4 )
+    t_flux( *transitions )
+      .pretty_print_numeric_values( gap: gap, precision: precision )
   end
+  alias pfluxes pflux
 
   # Reads the time range (initial_time .. target_time) of the simulation.
   #
@@ -125,7 +177,7 @@ module YPetri::Simulation::Timed
   #
   def increment_time! Δt=step
     @time += Δt
-    recorder.alert
+    recorder.alert!
   end
 
   # Resets the timed simulation.
@@ -138,10 +190,15 @@ module YPetri::Simulation::Timed
   # Customized dup method that allows to modify the attributes of
   # the duplicate upon creation.
   #
-  def dup time: time, **nn
-    super( **nn ).tap { |i| i.reset_time! time }
+  def dup time: time, **named_args
+    super( **named_args ).tap { |instance| instance.reset_time! time }
+  end
+
+  # Alias for +#dup+ for timed simulations.
+  # 
+  def at *args
+    dup *args
   end
-  alias at dup
 
   # Returns the zero gradient. Optionally, places can be specified, for which
   # the zero vector is returned.
@@ -155,6 +212,14 @@ module YPetri::Simulation::Timed
   end
   alias zero_∇ zero_gradient
 
+  protected
+
+  # Resets the time to initial time, or to the argument (if provided).
+  #
+  def reset_time! time=nil
+    @time = time.nil? ? initial_time : time
+  end
+
   private
 
   # Initialization subroutine for timed simulations. Expects named arguments
@@ -193,13 +258,17 @@ module YPetri::Simulation::Timed
     reset_time!
     @step = settings[:step] || time_unit
     @default_sampling = settings[:sampling] || step
-    @core = Core().new( method: method, guarded: guarded )
+    @core = if @guarded then
+              Core().guarded.new( method: method )
+            else
+              Core().new( method: method )
+            end
     @recorder = if features_to_record then
                   # we'll have to figure out features
                   ff = case features_to_record
                        when Array then
                          net.State.Features
-                           .infer_from_elements( features_to_record )
+                           .infer_from_nodes( features_to_record )
                        when Hash then
                          net.State.features( features_to_record )
                        end
@@ -213,13 +282,8 @@ module YPetri::Simulation::Timed
   # for timed simulations.
   # 
   def init_core_and_recorder_subclasses
-    param_class( { Core: YPetri::Core::Timed, Recorder: Recorder },
+    param_class( { Core: YPetri::Core.timed,
+                   Recorder: Recorder },
                  with: { simulation: self } )
   end
-
-  # Resets the time to initial time, or to the argument (if provided).
-  #
-  def reset_time! time=nil
-    @time = time.nil? ? initial_time : time
-  end
 end # module YPetri::Simulation::Timed

data/lib/y_petri/simulation/timeless/recorder.rb

@@ -1,18 +1,23 @@
 module YPetri::Simulation::Timeless
-  # A timeless recorder.
+  # Timeless recorder.
   # 
   class Recorder < YPetri::Simulation::Recorder
     attr_reader :next_event
 
     # Like +YPetri::Simulation::Recording#reset+, but allowing for additional
-    # named argument +:next_sample+ that sets the event (label, hash key) of
+    # named argument +:next_event+ that sets the event (label, hash key) of
     # the next sample.
     # 
-    def reset! **nn
-      super
-      @next_event = nn[:next_event] || 0
+    def reset! next_event: 0, **named_args
+      super.tap { @next_event = next_event }
     end
 
+    # Backsteps the simulation.
+    # 
+    def back!
+      fail NotImplementedError, "Backstep for timeless simulation not done yet!"
+    end
+    
     private
 
     # Records the current system state under a numbered sample.
@@ -21,5 +26,5 @@ module YPetri::Simulation::Timeless
       super next_event
       @next_event = @next_event.next # "event" shoud implement next method
     end
-  end # Recorder
+  end # class Recorder
 end # YPetri::Simulation::Timeless

data/lib/y_petri/simulation/timeless.rb

@@ -12,6 +12,12 @@ class YPetri::Simulation
       false
     end
 
+    # Changing the simulation method on the fly not supported.
+    # 
+    def set_simulation_method
+      fail NoMethodError, "Changing simulation method on the fly not supported!"
+    end
+
     private
 
     # Initialization subroutine for timeless simulations. Sets up the
@@ -22,13 +28,17 @@ class YPetri::Simulation
       method = settings[:method] # the simulation method
       features_to_record = settings[:record]
       init_core_and_recorder_subclasses
-      @core = Core().new( method: method, guarded: guarded )
+      @core = if @guarded then
+                Core().guarded.new( method: method )
+              else
+                Core().new( method: method )
+              end
       @recorder = if features_to_record then 
                     # we'll have to figure out features
                     ff = case features_to_record
                          when Array then
                            net.State.Features
-                             .infer_from_elements( features_to_record )
+                             .infer_from_nodes( features_to_record )
                          when Hash then
                            net.State.features( features_to_record )
                          end
@@ -42,7 +52,7 @@ class YPetri::Simulation
     # for timeless simulations.
     # 
     def init_core_and_recorder_subclasses
-      param_class( { Core: YPetri::Core::Timeless,
+      param_class( { Core: YPetri::Core.timeless,
                      Recorder: Recorder },
                    with: { simulation: self } )
     end

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

@@ -1,9 +1,9 @@
-#encoding: utf-8
+# encoding: utf-8
 
 # A mixin for A transition representations.
 # 
 module YPetri::Simulation::TransitionRepresentation::Type_A
-  attr_reader :assignment_closure
+  attr_reader :assignment_closure, :direct_assignment_closure
 
   # Assignment action -- true for A transitions.
   # 
@@ -54,6 +54,8 @@ module YPetri::Simulation::TransitionRepresentation::Type_A
   # Initialization subroutine.
   # 
   def init
+    @function = source.action_closure
+    @direct_assignment_closure = construct_direct_assignment_closure
     @assignment_closure = to_assignment_closure
   end
 
@@ -68,13 +70,13 @@ module YPetri::Simulation::TransitionRepresentation::Type_A
   # could change their values.
   # 
   def act
-    codomain >> Array( function.( *domain_marking ) )
+    codomain >> Array( function.( *domain.marking ) )
   end
 
   # Builds an assignment closure, which, when called, directly affects the
   # simulation's marking vector (free places only).
   # 
-  def to_assignment_closure
+  def construct_direct_assignment_closure
     mv, ac = simulation.m_vector, source.action_closure
     λ = if codomain.size == 1 then
           target = codomain.first
@@ -87,4 +89,22 @@ module YPetri::Simulation::TransitionRepresentation::Type_A
         end
     eval λ % domain_access_code( vector: :mv )
   end
+
+  # Builds an assignment closure, which is bound to the domain and upon calling,
+  # returns the assignment action given the current domain marking.
+  # 
+  def to_assignment_closure
+    build_closure
+  end
+
+  # Builds the A transition's function (asssignment action closure) into a
+  # closure already bound to the domain. Functions for A transitions have
+  # return value arity equal to the codomain size. The returned closure here
+  # ensures that the return value is always of Array type.
+  # 
+  def build_closure
+    mv, f = simulation.m_vector, function
+    λ = "-> { Array f.( %s ) }" % domain_access_code( vector: :mv )
+    eval λ
+  end
 end # class YPetri::Simulation::TransitionRepresentation::Type_A

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

@@ -1,4 +1,4 @@
-#encoding: utf-8
+# encoding: utf-8
 
 # A mixin for S transition representations.
 # 
@@ -41,5 +41,15 @@ class YPetri::Simulation::TransitionRepresentation
       @sparse_sv = Matrix.correspondence_matrix( codomain, places ) *
         stoichiometry.to_column_vector
     end
+
+    # Builds the S transition's function into a closure. Functions of
+    # S transitions return only a single number (flux for TS, firing for
+    # tS).
+    # 
+    def build_closure
+      mv, f = simulation.m_vector, function
+      λ = "-> { f.( %s ) }" % domain_access_code( vector: :mv )
+      eval λ
+    end
   end # module Type_S
 end # class YPetri::Simulation::TransitionRepresentation

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

@@ -1,4 +1,4 @@
-#encoding: utf-8
+# encoding: utf-8
 
 # A mixin for timed transition representations.
 # 

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

@@ -1,4 +1,4 @@
-#encoding: utf-8
+# encoding: utf-8
 
 # A mixin for Ts transition representations.
 # 

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

@@ -1,4 +1,4 @@
-#encoding: utf-8
+# encoding: utf-8
 
 # A mixin for non-assignment transition representations.
 # 

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

@@ -1,4 +1,4 @@
-#encoding: utf-8
+# encoding: utf-8
 
 # A mixin for s (nonstoichiometric) transition representations.
 # 
@@ -25,5 +25,16 @@ class YPetri::Simulation::TransitionRepresentation
     def init
       super
     end
+
+    # Builds the s transition's function into a closure. Functions for s
+    # transitions (nonstoichiometric transitions) have return value arity
+    # equal to the codomain size. The returned closure here ensures that
+    # the return value is always of Array type.
+    # 
+    def build_closure
+      mv, f = simulation.m_vector, function
+      λ = "-> { Array f.( %s ) }" % domain_access_code( vector: :mv )
+      eval λ
+    end
   end # module Type_s
 end # class YPetri::Simulation::TransitionRepresentation

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

@@ -1,4 +1,4 @@
-#encoding: utf-8
+# encoding: utf-8
 
 # A mixin for timed transition representations.
 # 

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

@@ -1,4 +1,4 @@
-#encoding: utf-8
+# encoding: utf-8
 
 # A mixin for tS transition representations.
 # 

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

@@ -1,4 +1,4 @@
-#encoding: utf-8
+# encoding: utf-8
 
 # A mixin for ts transition representations.
 # 

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

@@ -1,4 +1,4 @@
-#encoding: utf-8
+# encoding: utf-8
 
 require_relative 'a'
 require_relative 'A'

data/lib/y_petri/simulation/transition_representation.rb

@@ -3,9 +3,10 @@
 # Representation of a YPetri::Transition inside a YPetri::Simulation instance.
 #
 class YPetri::Simulation
-  class TransitionRepresentation < ElementRepresentation
+  class TransitionRepresentation < NodeRepresentation
     require_relative 'transition_representation/types'
-    include Types
+
+    ★ Types
 
     attr_reader :domain, :codomain
     attr_reader :function # source transition function
@@ -14,7 +15,7 @@ class YPetri::Simulation
     # 
     def initialize net_transition
       super
-      @domain, @codomain = places( source.domain ), places( source.codomain )
+      @domain, @codomain = Places( source.domain ), Places( source.codomain )
       type_init
     end
 
@@ -42,14 +43,6 @@ class YPetri::Simulation
       codomain.map { |p| free_places.index p }
     end
 
-    # Builds the transition's function into a closure.
-    # 
-    def build_closure
-      mv, f = simulation.m_vector, function
-      λ = "-> { f.( %s ) }" % domain_access_code( vector: :mv )
-      eval λ
-    end
-
     # Builds a code string for accessing the domain directly from a marking
     # vector, given as argument.
     #