y_petri 2.0.14 → 2.0.15

data/lib/y_petri/simulation.rb

@@ -1,15 +1,19 @@
 #encoding: utf-8
 
-# The Petri net model is agnostic of simulation settings. Only for the purpose
-# of simulation, model is combined together with specific simulation settings.
-# Simulation settings consist of global settings (time step, sampling rate...)
-# and object specific settings (clamps, constraints...). Again, clamps and
-# constraints *do not belong* to the model. The Petri net model is also agnostic
-# of the simulation methods. Simulation is not achieved by calling instance
-# methods of the model. Instead, Simulation class makes a 'mental image' of the
-# model, and uses that one in the actual simulation.
+require_relative 'simulation/collections'
+require_relative 'simulation/timed'
+
+# Represents a simulation of a Petri net, using certain method and settings.
+# Simulation concerns (simulation method and settings, initial values, marking
+# clamps, guards...) are separated from those Petri net domain model (existence,
+# naming, connectivity and function specification of the net). Again, clamps,
+# guards, initial values etc. <b>do not belong</b> to the model, although for
+# convenience, places may carry default initial marking, default guards, and
+# default clamps for use in simulations if none other are specified.
 #
 class YPetri::Simulation
+  include Collections
+
   SAMPLING_DECIMAL_PLACES = 5
   SIMULATION_METHODS =
     [
@@ -24,626 +28,30 @@ class YPetri::Simulation
     self.class.const_get :DEFAULT_SIMULATION_METHOD
   end
 
-  # Exposing @recording
-  # 
+  attr_reader :method, :guarded, :timed, :net
+  alias guarded? guarded
+  alias timed? timed
+  attr_reader :marking_vector
+  attr_reader :zero_ᴍ, :zero_gradient
   attr_reader :recording
   alias :r :recording
 
-  # Zero marking vector.
-  # 
-  attr_reader :zero_ᴍ
-
-  # Zero gradient.
-  # 
-  attr_reader :zero_gradient
-
-  # Simulation settings.
-  # 
-  def settings; {} end
-  alias :simulation_settings :settings
-
-  def recording_csv_string
-    CSV.generate do |csv|
-      @recording.keys.zip( @recording.values ).map{ |a, b| [ a ] + b.to_a }
-        .each{ |line| csv << line }
-    end        
-  end
-
-  # Currently, simulation is largely immutable. Net, initial marking, clamps
-  # and simulation settings are set upon initialization, whereupon the instance
-  # forms their "mental image", which remains immune to any subsequent changes
-  # to the original objects. Required parameters are :net, :marking_clamps, and
-  # :initial_marking. Optional is :method (simulation method), and :guarded
-  # (true/false, whether the simulation guards the transition function results).
-  # Guard conditions can be either implicit (guarding against negative values
-  # and against type changes in by transition action), or explicitly associated
-  # with either places, or transition function results.
-  # 
-  def initialize( method: default_simulation_method,
-                  guarded: false,
-                  net: raise( ArgumentError, "Net argument absent!" ),
-                  marking_clamps: {},
-                  initial_marking: {} )
-    puts "starting to set up Simulation" if YPetri::DEBUG
-    @method, @guarded, @net = method, guarded, net
-    @places, @transitions = @net.places.dup, @net.transitions.dup
-    self.singleton_class.class_exec {
-      define_method :Place do net.send :Place end
-      define_method :Transition do net.send :Transition end
-      define_method :Net do net.send :Net end
-      private :Place, :Transition, :Net
-    }; puts "setup of :net mental image complete" if YPetri::DEBUG
-
-    # A simulation distinguishes between free and clamped places. For free
-    # places, initial marking has to be specified. For clamped places, marking
-    # clamps have to be specified. Both come as hashes:
-    @marking_clamps = marking_clamps.with_keys { |k| place k }
-    @initial_marking = initial_marking.with_keys { |k| place k }
-    # Enforce that keys in the hashes must be unique:
-    @marking_clamps.keys.aT_equal @marking_clamps.keys.uniq
-    @initial_marking.keys.aT_equal @initial_marking.keys.uniq
-    puts "setup of clamps and initial marking done" if YPetri::DEBUG
-
-    # Each place must have either clamp, or initial marking:
-    places.each { |pl|
-      pl.aT "place #{pl}", "have either clamp or initial marking" do |pl|
-        ( @marking_clamps.keys + @initial_marking.keys ).include? pl
-      end
-    }; puts "clamp || initial marking test passed" if YPetri::DEBUG
-
-    # @F2A * ᴍ (marking vector of free places) maps ᴍ to all places.
-    @F2A = Matrix.correspondence_matrix( free_places, places )
-    # @C2A * marking_vector_of_clamped_places maps it to all places.
-    @C2A = Matrix.correspondence_matrix( clamped_places, places )
-    puts "correspondence matrices set up" if YPetri::DEBUG
-
-    # Stoichiometry matrices:
-    @S_for_tS = S_for tS_transitions()
-    @S_for_SR = S_for SR_transitions()
-    @S_for_TSr = S_for TSr_transitions()
-    puts "stoichiometry matrices set up" if YPetri::DEBUG
-
-    # Other assets:
-    @Δ_closures_for_tsa = create_Δ_closures_for_tsa
-    @Δ_closures_for_Tsr = create_Δ_closures_for_Tsr
-    @action_closures_for_tS = create_action_closures_for_tS
-    @action_closures_for_TSr = create_action_closures_for_TSr
-    @rate_closures_for_sR = create_rate_closures_for_sR
-    @rate_closures_for_SR = create_rate_closures_for_SR
-    @assignment_closures_for_A = create_assignment_closures_for_A
-    @zero_ᴍ = compute_initial_marking_vector_of_free_places.map { |e| e * 0 }
-    @zero_gradient = @zero_ᴍ.dup
-    puts "other assets set up, about to reset" if YPetri::DEBUG
-
-    reset!; puts "reset complete" if YPetri::DEBUG
-  end
-
-  # Returns a new instance of the system simulation at a specified state, with
-  # same simulation settings. This state (:marking argument) can be specified
-  # either as marking vector for free or all places, marking array for free or
-  # all places, or marking hash. If vector or array is given, its size must
-  # correspond to the number of either free, or all places. If hash is given,
-  # it is not necessary to specify marking of every place – marking of those
-  # left out will be left same as in the current state.
-  # 
-  def at( marking: marking, **oo )
-    err_msg = "Size of supplied marking must match either the number of " +
-      "free places, or the number of all places!"
-    update_method = case marking
-                    when Hash then :update_marking_from_a_hash
-                    when Matrix then
-                      case marking.column_to_a.size
-                      when places.size then :set_marking_vector
-                      when free_places.size then :set_ᴍ
-                      else raise TypeError, err_msg end
-                    else # marking assumed to be an array
-                      case marking.size
-                      when places.size then :set_marking
-                      when free_places.size then :set_m
-                      else raise TypeError, err_msg end
-                    end
-    return dup( **oo ).send( update_method, marking )
-  end
-
-  # Exposing @net.
-  # 
-  attr_reader :net
-
-  # Is the simulation guarded?
-  # 
-  def guarded?; @guarded end
-
-  # Without arguments or block, it returns simply a list of places. Otherwise,
-  # it returns a has whose keys are the places, and whose values are governed
-  # by the supplied parameters (either another collection, or message to #send
-  # to self to obtain a second collection).
+  # Stoichiometry matrix for *tS* transitions.
   # 
-  def places *aa, &b
-    return @places.dup if aa.empty? && b.nil?
-    zip_to_hash places, *aa, &b
-  end
-
-  # Without arguments or block, it returns simply a list of transitions.
-  # Otherwise, it returns a has whose keys are the places, and whose values are
-  # governed by the supplied parameters (either another collection, or message
-  # to #send to self to obtain a second collection).
-  # 
-  def transitions *aa, &b
-    return @transitions.dup if aa.empty? && b.nil?
-    zip_to_hash transitions, *aa, &b
-  end
-
-  # Without arguments or block, it returns simply a list of place names.
-  # Otherwise, it returns a hash whose keys are place names, and whose values
-  # are determined by the supplied argument(s) and/or block (either another
-  # collection, or a message to #send to self to obtain such collection). Unary
-  # block can be supplied to modify these values.
-  #
-  def pp *aa, &b
-    return places.map &:name if aa.empty? && b.nil?
-    zip_to_hash( places.map { |p| p.name || p }, *aa, &b )
-  end
-
-  # Without arguments or block, it returns simply a list of transition names.
-  # Otherwise, it returns a hash whose keys are transition names, and whose
-  # values are determined by the supplied argument(s) and/or block (either
-  # another collection, or a message to #send to self to obtain such collection).
-  # Unary block can be supplied to modify these values.
-  #
-  def tt *aa, &b
-    return transitions.map &:name if aa.empty? && b.nil?
-    zip_to_hash( transitions.map { |t| t.name || t }, *aa, &b )
-  end
-
-  # Without arguments or block, it returns simply a list of free places.
-  # Otherwise, it returns a hash, whose keys are the free places, and whose
-  # values are governed by the supplied parameters (either another collection,
-  # or message to #send to self to obtain a second collection).
-  # 
-  def free_places *aa, &b
-    return zip_to_hash free_places, *aa, &b unless aa.empty? && b.nil?
-    kk = @initial_marking.keys
-    places.select { |p| kk.include? p }
-  end
+  attr_reader :S_tS
 
-  # Behaves like #free_places, except that it uses place names instead of
-  # instances whenever possible.
+  # Stoichiometry matrix for *TSr* transitions.
   # 
-  def free_pp *aa, &b
-    return free_places.map { |p| p.name || p } if aa.empty? && b.nil?
-    zip_to_hash free_pp, *aa, &b
-  end
-
-  # Initial marking definitions for free places (array).
-  # 
-  def im
-    free_places.map { |p| @initial_marking[p] }
-  end
-
-  # Marking array of all places as it appears at the beginning of a simulation.
-  # 
-  def initial_marking
-    raise # FIXME: "Initial marking" for all places (ie. incl. clamped ones).
-  end
-
-  # Initial marking of free places as a column vector.
-  # 
-  def im_vector
-    Matrix.column_vector im
-  end
-  alias iᴍ im_vector
-
-  # Marking of all places at the beginning of a simulation, as a column vector.
-  # 
-  def initial_marking_vector
-    Matrix.column_vector initial_marking
-  end
+  attr_reader :S_TSr
 
-  # Without arguments or block, it returns simply a list of clamped places.
-  # Otherwise, it returns a hash, whose keys are the places, and whose values
-  # are governed by the supplied parameters (either another collection, or
-  # message to #send to self to obtain a second collection).
+  # Stoichiometry matrix for *SR* transitions.
   # 
-  def clamped_places *aa, &b
-    return zip_to_hash clamped_places, *aa, &b unless aa.empty? && b.nil?
-    kk = @marking_clamps.keys
-    places.select { |p| kk.include? p }
-  end
-
-  # Behaves like #clamped_places, except that it uses place names instead of
-  # instances whenever possible.
-  # 
-  def clamped_pp *aa, &b
-    return clamped_places.map { |p| p.name || p } if aa.empty? && b.nil?
-    zip_to_hash clamped_pp, *aa, &b
-  end
-
-  # Place clamp definitions for clamped places (array)
-  # 
-  def marking_clamps
-    clamped_places.map { |p| @marking_clamps[p] }
-  end
-  alias place_clamps marking_clamps
-
-  # Marking array of free places.
-  # 
-  def m
-    m_vector.column_to_a
-  end
-
-  # Marking hash of free places { name: marking }.
-  # 
-  def pm
-    free_pp :m
-  end
-  alias p_m pm
-
-  # Marking hash of free places { place: marking }.
-  # 
-  def place_m
-    free_places :m
-  end
-
-  # Marking array of all places.
-  # 
-  def marking
-    marking_vector ? marking_vector.column_to_a : nil
-  end
-
-  # Marking hash of all places { name: marking }.
-  # 
-  def pmarking
-    pp :marking
-  end
-  alias p_marking pmarking
-
-  # Marking hash of all places { place: marking }.
-  # 
-  def place_marking
-    places :marking
-  end
-
-  # Marking of a specified place(s)
-  # 
-  def marking_of place_or_collection_of_places
-    if place_or_collection_of_places.respond_to? :each then
-      place_or_collection_of_places.map { |pl| place_marking[ place( pl ) ] }
-    else
-      place_marking[ place( place_or_collection_of_places ) ]
-    end
-  end
-  alias m_of marking_of
-
-  # Marking of free places as a column vector.
-  # 
-  def m_vector
-    F2A().t * @marking_vector
-  end
-  alias ᴍ m_vector
-
-  # Marking of clamped places as a column vector.
-  # 
-  def marking_vector_of_clamped_places
-    C2A().t * @marking_vector
-  end
-  alias ᴍ_clamped marking_vector_of_clamped_places
-
-  # Marking of clamped places as an array.
-  # 
-  def marking_of_clamped_places
-    ᴍ_clamped.column( 0 ).to_a
-  end
-  alias m_clamped marking_of_clamped_places
-
-  # Marking of all places as a column vector.
-  # 
-  attr_reader :marking_vector
-
-  # Creation of stoichiometry matrix for an arbitrary array of stoichio.
-  # transitions, that maps (has the number of rows equal to) the free places.
-  # 
-  def S_for( array_of_S_transitions )
-    array_of_S_transitions.map { |t| sparse_σ t }
-      .reduce( Matrix.empty( free_places.size, 0 ), :join_right )
-  end
-
-  # Creation of stoichiometry matrix for an arbitrary array of stoichio.
-  # transitions, that maps (has the number of rows equal to) all the places.
-  # 
-  def stoichiometry_matrix_for( array_of_S_transitions )
-    array_of_S_transitions.map { |t| sparse_stoichiometry_vector t }
-      .reduce( Matrix.empty( places.size, 0 ), :join_right )
-  end
-
-  # 3. Stoichiometry matrix for timeless stoichiometric transitions.
-  # 
-  attr_reader :S_for_tS
-
-  # 4. Stoichiometry matrix for timed rateless stoichiometric transitions.
-  # 
-  attr_reader :S_for_TSr
-
-  # 6. Stoichiometry matrix for stoichiometric transitions with rate.
-  # 
-  attr_reader :S_for_SR
-
-  # Stoichiometry matrix, with the distinction, that the caller asserts,
-  # that all transitions in this simulation are stoichiometric transitions
-  # with rate (or error).
-  # 
-  def S
-    return S_for_SR() if s_transitions.empty? && r_transitions.empty?
-    raise "The simulation contains also non-stoichiometric transitions! " +
-      "Consider using #S_for_SR."
-  end
-
-  # ==== 1. Exposing ts transitions
-
-  # Without arguments or block, it returns simply a list of timeless
-  # nonstoichiometric transitions. Otherwise, it returns a hash, whose keys
-  # are the ts transitions, and values are governed by the supplied parameters
-  # (either another collection, or a message to #send to self to obtain the
-  # collection of values).
-  # 
-  def ts_transitions *aa, &b
-    return zip_to_hash ts_transitions, *aa, &b unless aa.empty? && b.nil?
-    sift_from_net :ts_transitions
-  end
-
-  # Like #ts_transitions, except that transition names are used instead of
-  # instances, whenever possible.
-  # 
-  def ts_tt *aa, &b
-    return zip_to_hash ts_tt, *aa, &b unless aa.empty? && b.nil?
-    ts_transitions.map { |t| t.name || t }
-  end
-
-  # Assignment transitions (A transition) can be regarded as a special kind
-  # of ts transition (subtracting away the current marking of their domain
-  # and replacing it with the result of their function). But it may often
-  # be useful to exclude A transitions from among the ts transitions, and
-  # such set is called tsa transitions (timeless nonstoichiometric
-  # nonassignment transitions).
-  # 
-  def tsa_transitions *aa, &b
-    return zip_to_hash tsa_transitions, *aa, &b unless aa.empty? && b.nil?
-    sift_from_net :tsa_transitions
-  end
-
-  # Like #tsa_transitions, except that transition names are used instead of
-  # instance, whenever possible.
-  # 
-  def tsa_tt *aa, &b
-    return zip_to_hash tsa_tt, *aa, &b unless aa.empty? && b.nil?
-    tsa_transitions.map { |t| t.name || t }
-  end
-
-  # ==== 2. Exposing tS transitions
-
-  # Without arguments or block, it returns simply a list of timeless
-  # stoichiometric transitions. Otherwise, it returns a hash, whose keys are
-  # the tS transitions, and values are governed by the supplied parameters
-  # (either another collection, or a message to #send to self to obtain the
-  # collection of values).
-  # 
-  def tS_transitions *aa, &b
-    return zip_to_hash tS_transitions, *aa, &b unless aa.empty? && b.nil?
-    sift_from_net :tS_transitions
-  end
-
-  # Like #tS_transitions, except that transition names are used instead of
-  # instances, whenever possible.
-  # 
-  def tS_tt *aa, &b
-    return zip_to_hash tS_tt, *aa, &b unless aa.empty? && b.nil?
-    tS_transitions.map { |t| t.name || t }
-  end
-
-  # ==== 3. Exposing Tsr transitions
-
-  # Without arguments or block, it returns simply a list of timed rateless
-  # nonstoichiometric transitions. Otherwise, it returns a hash, whose keys
-  # are the Tsr transitions, and whose values are governed by the supplied
-  # arguments (either an explicit collection of values, or a message to #send
-  # to self to obtain such collection).
-  # 
-  def Tsr_transitions *aa, &b
-    return zip_to_hash Tsr_transitions(), *aa, &b unless aa.empty? && b.nil?
-    sift_from_net :Tsr_transitions
-  end
-
-  # Like #Tsr_transitions, except that transition names are used instead of
-  # instances, whenever possible.
-  # 
-  def Tsr_tt *aa, &b
-    return zip_to_hash Tsr_tt(), *aa, &b unless aa.empty? && b.nil?
-    Tsr_transitions().map { |t| t.name || t }
-  end
-
-  # ==== 4. Exposing TSr transitions
-
-  # Without arguments or block, it returns simply a list of timed rateless
-  # stoichiometric transitions. Otherwise, it returns a hash, whose keys are
-  # are the TSr transitions, and whose values are governed by the supplied
-  # arguments (either an explicit collection of values, or a message to #send
-  # to self to obtain such collection).
-  # 
-  def TSr_transitions *aa, &b
-    return zip_to_hash TSr_transitions(), *aa, &b unless aa.empty? && b.nil?
-    sift_from_net :TSr_transitions
-  end
-
-  # Like #TSr_transitions, except that transition names are used instead of
-  # instances, whenever possible.
-  # 
-  def TSr_tt *aa, &b
-    return zip_to_hash TSr_tt(), *aa, &b unless aa.empty? && b.nil?
-    TSr_transitions().map { |t| t.name || t }
-  end
-
-  # ==== 5. Exposing sR transitions
-
-  # Without arguments or block, it returns simply a list of nonstoichiometric
-  # transitions with rate. Otherwise, it returns a hash, whose keys are
-  # are the sR transitions, and whose values are governed by the supplied
-  # arguments (either an explicit collection of values, or a message to #send
-  # to self to obtain such collection).
-  # 
-  def sR_transitions *aa, &b
-    return zip_to_hash sR_transitions(), *aa, &b unless aa.empty? && b.nil?
-    sift_from_net :sR_transitions
-  end
-
-  # Like #sR_transitions, except that transition names are used instead of
-  # instances, whenever possible.
-  # 
-  def sR_tt *aa, &b
-    return zip_to_hash sR_tt(), *aa, &b unless aa.empty? && b.nil?
-    sR_transitions.map { |t| t.name || t }
-  end
-
-  # ==== 6. Exposing SR transitions
-
-  # Without arguments or block, it returns simply a list of stoichiometric
-  # transitions with rate. Otherwise, it returns a hash, whose keys are
-  # are the SR transitions, and whose values are governed by the supplied
-  # arguments (either an explicit collection of values, or a message to #send
-  # to self to obtain such collection).
-  # 
-  def SR_transitions *aa, &b
-    return zip_to_hash SR_transitions(), *aa, &b unless aa.empty? && b.nil?
-    sift_from_net :SR_transitions
-  end
-
-  # Like #SR_transitions, except that transition names are used instead of
-  # instances, whenever possible.
-  # 
-  def SR_tt *aa, &b
-    return zip_to_hash SR_tt(), *aa, &b unless aa.empty? && b.nil?
-    SR_transitions().map { |t| t.name || t }
-  end
-
-  # ==== Assignment (A) transitions
-
-  # Without arguments or block, it returns simply a list of assignment
-  # transitions. Otherwise, it returns a hash, whose keys are the A
-  # transitions, and whose values are governed by the supplied arguments
-  # (either an explicit collection of values, or a message to #send
-  # to self to obtain such collection).
-  # 
-  def A_transitions *aa, &b
-    return zip_to_hash A_transitions(), *aa, &b unless aa.empty? && b.nil?
-    sift_from_net :A_transitions
-  end
-  alias assignment_transitions A_transitions
-
-  # Like #A_transitions, except that transition names are used instead of
-  # instances, whenever possible.
-  # 
-  def A_tt *aa, &b
-    return zip_to_hash A_tt(), *aa, &b unless aa.empty? && b.nil?
-    A_transitions().map { |t| t.name || t }
-  end
-  alias assignment_tt A_tt
-
-  # ==== Stoichiometric transitions of any kind (S transitions)
-
-  # Without arguments or block, it returns simply a list of stoichiometric
-  # transitions. Otherwise, it returns a hash, whose keys are the S
-  # transitions, and whose values are governed by the supplied arguments
-  # (either an explicit collection of values, or a message to #send to
-  # self to obtain such collection).
-  # 
-  def S_transitions *aa, &b
-    return zip_to_hash S_transitions(), *aa, &b unless aa.empty? && b.nil?
-    sift_from_net :S_transitions
-  end
-
-  # Like #S_transitions, except that transition names are used instead of
-  # instances, whenever possible.
-  # 
-  def S_tt *aa, &b
-    return zip_to_hash S_tt(), *aa, &b unless aa.empty? && b.nil?
-    S_transitions().map { |t| t.name || t }
-  end
-
-  # ==== Nonstoichiometric transitions of any kind (s transitions)
-
-  # Without arguments or block, it returns simply a list of
-  # nonstoichiometric transitions. Otherwise, it returns a hash, whose
-  # keys are the s transitions, and whose values are governed by the
-  # supplied arguments (either an explicit collection of values, or a
-  # message to #send to self to obtain such collection).
-  # 
-  def s_transitions *aa, &b
-    return zip_to_hash s_transitions, *aa, &b unless aa.empty? && b.nil?
-    sift_from_net :s_transitions
-  end
-
-  # Like #s_transitions, except that transition names are used instead of
-  # instances, whenever possible.
-  # 
-  def s_tt *aa, &b
-    return zip_to_hash s_tt, *aa, &b unless aa.empty? && b.nil?
-    s_transitions.map { |t| t.name || t }
-  end
-
-  # ==== Transitions with rate (R transitions), otherwise of any kind
-
-  # Without arguments or block, it returns simply a list of transitions
-  # with rate. Otherwise, it returns a hash, whose keys are the R
-  # transitions, and whose values are governed by the supplied arguments
-  # (either an explicit collection of values, or a message to #send to
-  # self to obtain such collection).
-  # 
-  def R_transitions *aa, &b
-    return zip_to_hash R_transitions(), *aa, &b unless aa.empty? && b.nil?
-    sift_from_net :R_transitions
-  end
-
-  # Like #s_transitions, except that transition names are used instead of
-  # instances, whenever possible.
-  # 
-  def R_tt *aa, &b
-    return zip_to_hash R_tt(), *aa, &b unless aa.empty? && b.nil?
-    R_transitions().map { |t| t.name || t }
-  end
-
-  # ==== Rateless transitions (r transitions), otherwise of any kind
-
-  # Without arguments or block, it returns simply a list of rateless
-  # transitions. Otherwise, it returns a hash, whose keys are the r
-  # transitions, and whose values are governed by the supplied arguments
-  # (either an explicit collection of values, or a message to #send to
-  # self to obtain such collection).
-  # 
-  def r_transitions *aa, &b
-    return zip_to_hash r_transitions, *aa, &b unless aa.empty? && b.nil?
-    sift_from_net :r_transitions
-  end
-
-  # Like #r_transitions, except that transition names are used instead of
-  # instances, whenever possible.
-  # 
-  def r_tt *aa, &b
-    return zip_to_hash r_tt, *aa, &b unless aa.empty? && b.nil?
-    r_transitions.map { |t| t.name || t }
-  end
-
-  # === Methods presenting other simulation assets
-
-  # ==== Regarding ts transitions
-  # 
-  # (Their closures supply directly Δ codomain.)
+  attr_reader :S_SR
 
   # Exposing Δ state closures for ts transitions.
   # 
   attr_reader :Δ_closures_for_tsa
 
-  # Delta state contribution if timed nonstoichiometric non-assignment (tsa)
-  # transitions fire once. The closures are called in their order, but the state
-  # update is not performed between the calls (they fire simultaneously).
-  #
   # Note: 'a' in 'tsa' is needed because A (assignment) transitions can also be
   # regarded as a special kind of ts transitions, while they obviously do not
   # act through Δ state, but rather directly enforce marking of their codomain.
@@ -652,29 +60,16 @@ class YPetri::Simulation
     Δ_closures_for_tsa.map( &:call ).reduce( @zero_ᴍ, :+ )
   end
 
-  # ==== Regarding Tsr transitions
-  # 
-  # (Their closures do take Δt as argument, but do not expose their ∂,
-  # and they might not even have one.)
-
   # Exposing Δ state closures for Tsr transitions.
   # 
   attr_reader :Δ_closures_for_Tsr
 
   # Delta state contribution for Tsr transitions given Δt.
   # 
-  def Δ_for_Tsr( Δt )
+  def Δ_Tsr( Δt )
     Δ_closures_for_Tsr.map { |cl| cl.( Δt ) }.reduce( @zero_ᴍ, :+ )
   end
-
-  # ==== Regarding tS transitions
-  # 
-  # (These transitions are timeless, but stoichiometric. It means that their
-  # closures do not output Δ state contribution directly, but instead they
-  # output a single number, which is a transition action, and Δ state is then
-  # computed from it by multiplying the the action vector with the
-  # stoichiometry matrix.
-
+  
   # Exposing action closures for tS transitions.
   # 
   attr_reader :action_closures_for_tS
@@ -686,7 +81,7 @@ class YPetri::Simulation
   def action_vector_for_tS
     Matrix.column_vector action_closures_for_tS.map( &:call )
   end
-  alias α_for_tS action_vector_for_tS
+  alias ᴀ_tS action_vector_for_tS
 
   # Action vector if tS transitions fire once, like the previous method.
   # But by calling this method, the caller asserts that all timeless
@@ -698,20 +93,14 @@ class YPetri::Simulation
       "transitions! Consider using #action_vector_for_tS."
   end
   alias action_vector_for_t action_vector_for_timeless_transitions
-  alias α_for_t action_vector_for_timeless_transitions
+  alias ᴀ_t action_vector_for_timeless_transitions
 
   # Δ state contribution for tS transitions.
   # 
   def Δ_if_tS_fire_once
-    S_for_tS() * action_vector_for_tS
+    S_tS() * action_vector_for_tS
   end
 
-  # ==== Regarding TSr transitions
-  # 
-  # (Same as Tsr, but stoichiometric. That is, their closures do not return
-  # Δ contribution, but transition's action, which is to be multiplied by
-  # the its stoichiometry to obtain Δ contribution.)
-
   # Exposing action closures for TSr transitions.
   # 
   attr_reader :action_closures_for_TSr
@@ -730,7 +119,7 @@ class YPetri::Simulation
   def action_vector_for_TSr( Δt )
     Matrix.column_vector action_closures_for_TSr.map { |c| c.( Δt ) }
   end
-  alias α_for_TSr action_vector_for_TSr
+  alias ᴀ_TSr action_vector_for_TSr
 
   # Action vector for timed rateless stoichiometric transitions
   # By calling this method, the caller asserts that all timeless transitions
@@ -741,20 +130,14 @@ class YPetri::Simulation
     raise "The simulation also contains nonstoichiometric timed rateless " +
       "transitions! Consider using #action_vector_for_TSr."
   end
-  alias α_for_Tr action_vector_for_Tr
+  alias ᴀ_Tr action_vector_for_Tr
 
-  # Computes delta state for TSr transitions, given a Δt.
+  # State contribution of TSr transitions for the period Δt.
   # 
-  def Δ_for_TSr( Δt )
-    S_for_TSr() * action_vector_for_TSr( Δt )
+  def Δ_TSr( Δt )
+    S_TSr() * action_vector_for_TSr( Δt )
   end
 
-  # ==== Regarding sR transitions
-  # 
-  # (Whether nonstoichiometric or stoichiometric, transitions with rate
-  # explicitly provide their contribution to the the state differential,
-  # rather than just contribution to the Δ state.)
-
   # Exposing rate closures for sR transitions.
   # 
   attr_reader :rate_closures_for_sR
@@ -781,20 +164,11 @@ class YPetri::Simulation
     free_pp :gradient_for_sR
   end
 
-  # While for sR transitions, state differential is what matters the most,
-  # as a conveniece, this method for multiplying the differential by provided
-  # Δt is added.
+  # First-order state contribution of sR transitions during Δt.
   # 
-  def Δ_Euler_for_sR( Δt )
+  def Δ_sR( Δt )
     gradient_for_sR * Δt
   end
-  alias Δ_euler_for_sR Δ_Euler_for_sR
-
-  # ==== Regarding SR_transitions
-  # 
-  # (Whether nonstoichiometric or stoichiometric, transitions with rate
-  # explicitly provide their contribution to the the state differential,
-  # rather than just contribution to the Δ state.)
 
   # Exposing rate closures for SR transitions.
   # 
@@ -891,7 +265,7 @@ class YPetri::Simulation
   # State differential for SR transitions.
   # 
   def gradient_for_SR
-    S_for_SR() * flux_vector_for_SR
+    S_SR() * flux_vector_for_SR
   end
 
   # State differential for SR transitions as a hash { place_name: ∂ / ∂ᴛ }.
@@ -900,44 +274,30 @@ class YPetri::Simulation
     free_pp :gradient_for_SR
   end
 
-  # Action vector for SR transitions under an assumption of making an Euler
-  # step, whose size is given by the Δt argument.
+  # First-order action vector for SR transitions for the time period Δt.
   # 
-  def Euler_action_vector_for_SR( Δt )
+  def first_order_action_vector_for_SR( Δt )
     flux_vector_for_SR * Δt
   end
-  alias euler_action_vector_for_SR Euler_action_vector_for_SR
-  alias Euler_α_for_SR Euler_action_vector_for_SR
-  alias euler_α_for_SR Euler_action_vector_for_SR
+  alias ᴀ_SR first_order_action_vector_for_SR
 
-  # Euler action fro SR transitions as an array.
+  # First-order action (as array) for SR for the time period Δt.
   # 
-  def Euler_action_for_SR( Δt )
-    Euler_action_vector_for_SR( Δt ).column( 0 ).to_a
+  def first_order_action_for_SR( Δt )
+    first_order_action_vector_for_SR( Δt ).column( 0 ).to_a
   end
-  alias euler_action_for_SR Euler_action_for_SR
 
-  # Convenience calculator of Δ state for SR transitions, assuming a single
-  # Euler step with Δt given as argument.
+  # First-order state contribution of SR transitions during Δt.
   # 
-  def Δ_Euler_for_SR( Δt )
+  def Δ_SR( Δt )
     gradient_for_SR * Δt
   end
-  alias Δ_euler_for_SR Δ_Euler_for_SR
 
-  # Δ state for SR transitions, assuming Euler step with Δt as the argument,
-  # returned as an array.
+  # First-order state contribution for SR transitions during Δt (as array).
   # 
-  def Δ_Euler_array_for_SR( Δt )
+  def Δ_array_for_SR( Δt )
     Δ_Euler_for_SR( Δt ).column( 0 ).to_a
   end
-  alias Δ_euler_array_for_SR Δ_Euler_array_for_SR
-
-
-  # ==== Regarding A transitions
-  # 
-  # (Assignment transitions directly replace the values in their codomain
-  # places with their results.)
 
   # Exposing assignment closures for A transitions.
   #
@@ -977,6 +337,150 @@ class YPetri::Simulation
     # TODO: Assignment action to a clamped place should result in a warning.
   end
 
+  # Correspondence matrix free places => all places.
+  # 
+  attr_reader :F2A
+
+  # Correspondence matrix clamped places => all places.
+  # 
+  attr_reader :C2A
+
+  # Simulation settings.
+  # 
+  def settings; {} end
+  alias :simulation_settings :settings
+
+  def recording_csv_string
+    CSV.generate do |csv|
+      @recording.keys.zip( @recording.values ).map{ |a, b| [ a ] + b.to_a }
+        .each{ |line| csv << line }
+    end        
+  end
+
+  # Currently, simulation is largely immutable. Net, initial marking, clamps
+  # and simulation settings are set upon initialization, whereupon the instance
+  # forms their "mental image", which remains immune to any subsequent changes
+  # to the original objects. Required parameters are :net, :marking_clamps, and
+  # :initial_marking. Optional is :method (simulation method), and :guarded
+  # (true/false, whether the simulation guards the transition function results).
+  # Guard conditions can be either implicit (guarding against negative values
+  # and against type changes in by transition action), or explicitly associated
+  # with either places, or transition function results.
+  # 
+  # A simulation distinguishes between free and clamped places. For free
+  # places, initial marking has to be specified. For clamped places, marking
+  # clamps have to be specified. Both come as hashes:
+  # 
+  # In addition to the arguments required by the regular simulation
+  # constructor, timed simulation constructor also expects :step_size
+  # (alias :step), :sampling_period (alias :sampling), and :target_time
+  # named arguments.
+  # 
+  def initialize( method: default_simulation_method,
+                  guarded: false,
+                  marking_clamps: {},
+                  initial_marking: {},
+                  **nn )
+    puts "constructing a simulation" if YPetri::DEBUG
+
+    @method, @guarded = method, guarded
+    @net = nn.fetch( :net )
+    @places, @transitions = @net.places.dup, @net.transitions.dup
+    self.singleton_class.class_exec {
+      define_method :Place do net.send :Place end
+      define_method :Transition do net.send :Transition end
+      define_method :Net do net.send :Net end
+      private :Place, :Transition, :Net
+    }; puts "setup of :net mental image complete" if YPetri::DEBUG
+
+    @marking_clamps = marking_clamps.with_keys { |k| place k }
+    @initial_marking = initial_marking.with_keys { |k| place k }
+    # Enforce that keys in the hashes must be unique:
+    @marking_clamps.keys.aT_equal @marking_clamps.keys.uniq
+    @initial_marking.keys.aT_equal @initial_marking.keys.uniq
+    puts "setup of clamps and initial marking done" if YPetri::DEBUG
+
+    places.each { |pl| # each place must have either clamp, or initial marking
+      pl.aT "place #{pl}", "have either clamp or initial marking" do |pl|
+        ( @marking_clamps.keys + @initial_marking.keys ).include? pl
+      end
+    }; puts "clamp || initial marking test passed" if YPetri::DEBUG
+
+    # @F2A * ᴍ (marking vector of free places) maps ᴍ to all places.
+    @F2A = Matrix.correspondence_matrix( free_places, places )
+    # @C2A * marking_vector_of_clamped_places maps it to all places.
+    @C2A = Matrix.correspondence_matrix( clamped_places, places )
+    puts "correspondence matrices set up" if YPetri::DEBUG
+
+    # Stoichiometry matrices:
+    @S_tS = S_for tS_transitions()
+    @S_SR = S_for SR_transitions()
+    @S_TSr = S_for TSr_transitions()
+    puts "stoichiometry matrices set up" if YPetri::DEBUG
+
+    # Other assets:
+    @Δ_closures_for_tsa = create_Δ_closures_for_tsa
+    @Δ_closures_for_Tsr = create_Δ_closures_for_Tsr
+    @action_closures_for_tS = create_action_closures_for_tS
+    @action_closures_for_TSr = create_action_closures_for_TSr
+    @rate_closures_for_sR = create_rate_closures_for_sR
+    @rate_closures_for_SR = create_rate_closures_for_SR
+    @assignment_closures_for_A = create_assignment_closures_for_A
+    @zero_ᴍ = compute_initial_marking_vector_of_free_places.map { |e| e * 0 }
+    @zero_gradient = @zero_ᴍ.dup
+    puts "other assets set up" if YPetri::DEBUG
+
+    @timed = if nn.has?( :time ) || nn.has?( :step ) || nn.has?( :sampling )
+               extend Timed
+               true
+             else false end
+
+    if timed? then # we have to set up all the expected variables
+      if nn[:time] then # time range given
+        time_range = nn[:time]
+        @initial_time, @target_time = time_range.begin, time_range.end
+        @step_size = nn[:step] || target_time / target_time.to_f
+        @sampling_period = nn[:sampling] || step_size
+      else
+        anything = nn[:step] || nn[:sampling]
+        @initial_time, @target_time = anything * 0, anything * Float::INFINITY
+        @step_size = nn[:step] || anything / anything.to_f
+        @sampling_period = nn[:sampling] || step_size
+      end
+    end
+
+    puts "timedness of the simulation decided" if YPetri::DEBUG 
+
+    reset!
+  end
+
+  # Returns a new instance of the system simulation at a specified state, with
+  # same simulation settings. This state (:marking argument) can be specified
+  # either as marking vector for free or all places, marking array for free or
+  # all places, or marking hash. If vector or array is given, its size must
+  # correspond to the number of either free, or all places. If hash is given,
+  # it is not necessary to specify marking of every place – marking of those
+  # left out will be left same as in the current state.
+  # 
+  def at( marking: marking, **nn )
+    err_msg = "Size of supplied marking must match either the number of " +
+      "free places, or the number of all places!"
+    update_method = case marking
+                    when Hash then :update_marking_from_a_hash
+                    when Matrix then
+                      case marking.column_to_a.size
+                      when places.size then :set_marking_vector
+                      when free_places.size then :set_ᴍ
+                      else fail TypeError, err_msg end
+                    else # marking assumed to be an array
+                      case marking.size
+                      when places.size then :set_marking
+                      when free_places.size then :set_m
+                      else fail TypeError, err_msg end
+                    end
+    return dup( **nn ).send( update_method, marking )
+  end
+
   # ==== Sparse stoichiometry vectors for transitions
 
   # For the transition specified by the argument, this method returns the
@@ -1001,14 +505,6 @@ class YPetri::Simulation
       Matrix.column_vector( instance.stoichiometry )
   end
 
-  # Correspondence matrix free places => all places.
-  # 
-  attr_reader :F2A
-
-  # Correspondence matrix clamped places => all places.
-  # 
-  attr_reader :C2A
-
   # Produces the inspect string of the transition.
   # 
   def inspect
@@ -1023,34 +519,6 @@ class YPetri::Simulation
 
   private
 
-  # This helper method takes a collection, a variable number of other arguments
-  # and an optional block, and returns a hash whose keys are the collection
-  # members, and whose values are given by the supplied othe arguments and/or
-  # block in the following way: If there is no additional argument, but a block
-  # is supplied, this is applied to the collection. If there is exactly one
-  # other argument, and it is also a collection, it is used as values.
-  # Otherwise, these other arguments are treated as a message to be sent to
-  # self (via #send), expecting it to return a collection to be used as hash
-  # values. Optional block (which is always assumed to be unary) can be used
-  # to additionally modify the second collection.
-  # 
-  def zip_to_hash collection, *args, &block
-    sz = args.size
-    values = if sz == 0 then collection
-             elsif sz == 1 && args[0].respond_to?( :each ) then args[0]
-             else send *args end
-    Hash[ collection.zip( block ? values.map( &block ) : values ) ]
-  end
-
-  # Chicken approach towards ensuring that transitions in question come in
-  # the same order as in @transitions local variable. Takes a symbol as the
-  # argument (:SR, :TSr, :sr etc.)
-  # 
-  def sift_from_net type_of_transitions
-    from_net = net.send type_of_transitions
-    @transitions.select { |t| from_net.include? t }
-  end
-
   # Resets the simulation
   # 
   def reset!
@@ -1334,8 +802,8 @@ end
 
   # Duplicate creation.
   # 
-  def dup( **oo )
-    self.class.new( oo.reverse_merge!( { method: @method,
+  def dup( **nn )
+    self.class.new( nn.reverse_merge!( { method: @method,
                                          guarded: @guarded,
                                          net: @net,
                                          marking_clamps: @marking_clamps,