y_petri 2.0.14 → 2.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 04fefe57afd5fa9850489c3d5dcfe27ffd520e05
-  data.tar.gz: f544785cc23baa8b9d26d0afb15984d8c85c59a4
+  metadata.gz: 3c819010da78d8924cb320612edc32744c5d745a
+  data.tar.gz: f3320f25920735b13fa67be3793fa3dd768915fc
 SHA512:
-  metadata.gz: 705160694568b66998cbeff7a273113e5a84f80d97f14fe161c427bf95d06894e4eee6d0cc8a7b9e4f60aec4c1483b8685826df339de92c3a7856eda4a3c8f3b
-  data.tar.gz: 98e978bf1c89bcef1bac79c5b1f3a90dbfc48fc98842cd18569f46a672a2484853fc0a7d1d1f1e70c883db6a13c849e85e888b98ac1d7702733d34c4dbe95969
+  metadata.gz: e65d106f512773919f4fcf810927ac7f61c8c0e50c0faeea4b23c7671b2ae175a770ef8ce4da9d08366eb14b55e021b7949965b9c55de7f86f501d8f25128561
+  data.tar.gz: 834d55aeb5103d792a2ff8370352802278815fea76c6286bb465e59973a9e9166c24bce73309d20da1ca85303581cf0ac5cfc015c763f26a3287024dcbc37cdc

data/lib/y_petri/manipulator/simulation_related_methods.rb

@@ -192,14 +192,19 @@ module YPetri::Manipulator::SimulationRelatedMethods
   end
   alias set_step_size set_step
 
-  # Changes the simulation time of the current ssc (ssc = simulation
-  # settings collection).
+  # Sets the time frame of the current ssc (sim. settings collection).
   # 
-  def set_time t
-    ssc.update target_time: t
+  def set_time time_range
+    ssc.update time: time_range.aT_kind_of( Range )
   end
-  alias set_target_time set_time
 
+  # Sets the time frame of the current ssc to run from zero to the time supplied
+  # as the argument.
+  # 
+  def set_target_time time
+    set_time time * 0 .. time
+  end
+    
   # Changes the sampling period of the current ssc (ssc = simulation
   # settings collection).
   # 

data/lib/y_petri/net.rb

@@ -113,14 +113,14 @@ class YPetri::Net
 
   # Creates a new simulation from the net.
   # 
-  def new_simulation( **named_args )
-    YPetri::Simulation.new **named_args.merge( net: self )
+  def new_simulation( **nn )
+    YPetri::Simulation.new **nn.merge( net: self )
   end
 
   # Creates a new timed simulation from the net.
   # 
-  def new_timed_simulation( **named_args )
-    YPetri::TimedSimulation.new **named_args.merge( net: self )
+  def new_timed_simulation( **nn )
+    new_simulation( **nn ).aT &:timed?
   end
 
   # Networks are equal when their places and transitions are equal.

data/lib/y_petri/place/guard.rb

@@ -6,9 +6,13 @@ class YPetri::Place
   # Marking guard.
   # 
   class Guard
-    ERRMSG = -> m, assert { "Marking #{m}:#{m.class} #{assert}!" }
+    ERRMSG = -> m, of, assert do
+      "Marking #{m}:#{m.class}" +
+        if of then " of #{of.name || of rescue of}" else '' end +
+        " #{assert}!"
+    end
 
-    attr_reader :assertion, :block
+    attr_reader :place, :assertion, :block
 
     # Requires a NL guard assertion (used in GuardError messages), and a guard
     # block expressing the same assertion formally, in code.  Attention: *Only
@@ -21,8 +25,8 @@ class YPetri::Place
     # automatically raise appropriately worded +GuardError+. See also:
     # {+YPetri#guard+ method}[rdoc-ref:YPetri::guard].
     # 
-    def initialize assertion_NL_string, &block
-      @assertion, @block = assertion_NL_string, block
+    def initialize( assertion_NL_string, place: nil, &block )
+      @place, @assertion, @block = place, assertion_NL_string, block
       @Lab = Class.new BasicObject do
         def initialize λ; @λ = λ end
         def fail; @λ.call end
@@ -32,9 +36,9 @@ class YPetri::Place
     # Validates a supplied marking value against the guard block. Raises
     # +YPetri::GuardError+ if the guard fails, otherwise returns _true_.
     # 
-    def validate( marking_value )
-      λ = __fail__( marking_value, assertion )
-      λ.call if @Lab.new( λ ).instance_exec( marking_value, &block ) == false
+    def validate( marking )
+      λ = __fail__( marking, assertion )
+      λ.call if @Lab.new( λ ).instance_exec( marking, &block ) == false
       return true
     end
 
@@ -42,8 +46,9 @@ class YPetri::Place
 
     # Constructs the fail closure.
     # 
-    def __fail__ marking_value, assertion
-      -> { fail YPetri::GuardError, ERRMSG.( marking_value, assertion ) }
+    def __fail__ marking, assertion
+      pl = place
+      -> { fail YPetri::GuardError, ERRMSG.( marking, pl, assertion ) }
     end
   end
 
@@ -80,7 +85,7 @@ class YPetri::Place
   # were given (behaving as +#federated_guard_closure+ alias in this case).
   # 
   def guard *args, &block
-    if block then @guards << Guard.new( *args, &block )
+    if block then @guards << Guard.new( *args, place: name || self, &block )
     elsif args.size == 1 then federated_guard_closure.( args[0] )
     elsif args.empty? then federated_guard_closure
     end
@@ -91,8 +96,8 @@ class YPetri::Place
   # blocks pass for the given marking value.
   # 
   def federated_guard_closure
-    lineup = guards.dup
-    -> m { lineup.each { |g| g.validate m }; return m }
+    place_name, lineup = name.to_s, guards.dup
+    -> m { lineup.each { |g| g.validate( m ) }; return m }
   end
 
   # Applies guards on the marking currently owned by the place.

data/lib/y_petri/simulation/collections.rb

@@ -0,0 +1,460 @@
+#encoding: utf-8
+
+# Mixin that provides methods exposing place and transition collections to
+# YPetri::Simulation.
+#
+class YPetri::Simulation
+  module Collections
+    # Returns the simulation's places. Optional arguments / block make it return
+    # a hash <tt>places => values</tt>, such as:
+    #
+    #   places :marking
+    #   #=> { <Place:Foo> => 42, <Place:Bar> => 43, ... }
+    # 
+    def places *aa, &b
+      return @places.dup if aa.empty? && b.nil?
+      zip_to_hash places, *aa, &b
+    end
+
+    # Returns the simulation's transitions. Optional arguments / block make it
+    # return a hash <tt>places => values</tt>, such as:
+    #
+    # transitions :flux
+    # #=> { <Transition:Baz> => 42, <Transition:Quux => 43, ... }
+    # 
+    def transitions *aa, &b
+      return @transitions.dup if aa.empty? && b.nil?
+      zip_to_hash transitions, *aa, &b
+    end
+
+    # Like #places method, except that in the output, names are used instead of
+    # place instances when possible.
+    # 
+    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
+
+    # Like #transitions method, except that in the output, names are used
+    # instead of transition instances when possible.
+    # 
+    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
+
+    # Returns the simulation's free places, with same syntax options as #places
+    # method.
+    # 
+    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
+
+    # Like #free_places, except that in the output, names are used instead of
+    # place instances when possible.
+    # 
+    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 (as 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 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 column vector).
+    # 
+    def initial_marking_vector
+      Matrix.column_vector initial_marking
+    end
+
+    # Returns the simulation's clamped places, with same syntax options as #places
+    # method.
+    # 
+    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
+
+    # Like #clamped_places, except that in the output, names are used instead of
+    # place 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 (as array)
+    # 
+    def marking_clamps
+      clamped_places.map { |p| @marking_clamps[p] }
+    end
+    alias place_clamps marking_clamps
+
+    # Marking of free places (as array).
+    # 
+    def m
+      m_vector.column_to_a
+    end
+
+    # Marking of free places (as hash of pairs <tt>{ name: marking }</tt>).
+    # 
+    def pm
+      free_pp :m
+    end
+    alias p_m pm
+
+    # Marking of free places (as hash of pairs <tt>{ place: marking }</tt>.
+    # 
+    def place_m
+      free_places :m
+    end
+
+    # Marking of all places (as array).
+    # 
+    def marking
+      marking_vector ? marking_vector.column_to_a : nil
+    end
+
+    # Marking of all places (as hash of pairs <tt>{ name: marking }</tt>).
+    # 
+    def p_marking
+      pp :marking
+    end
+    alias pmarking p_marking
+
+    # Marking of all places (as hash of pairs <tt>{ place: marking }</tt>.
+    # 
+    def place_marking
+      places :marking
+    end
+
+    # Marking of a specified place or a collection of places.
+    # 
+    def marking_of places
+      m = place_marking
+      return places.map { |pl| m[ place( pl ) ] } if places.respond_to? :each
+      m[ place( place_or_places ) ]
+    end
+    alias m_of marking_of
+
+    # Marking of free places ( as column vector).
+    # 
+    def m_vector
+      F2A().t * @marking_vector
+    end
+    alias ᴍ m_vector
+
+    # Marking of clamped places (as 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 array).
+    # 
+    def marking_of_clamped_places
+      marking_vector_of_clamped_places.column( 0 ).to_a
+    end
+    alias m_clamped marking_of_clamped_places
+
+    # Returns a stoichiometry matrix for an arbitrary array of stoichiometric
+    # transitions. The returned stoichiometry matrix has the number of columns
+    # equal to the number of supplied stoichimetric transitions, and the number
+    # of rows equal to the number of free places. When multiplied by a vector
+    # corresponding to the transitions (such as flux vector), the resulting
+    # column vector corresponds to the free places.
+    # 
+    def S_for( stoichiometric_transitions )
+      stoichiometric_transitions.map { |t| sparse_σ t }
+        .reduce( Matrix.empty( free_places.size, 0 ), :join_right )
+    end
+
+    # Returns a stoichiometry matrix for an arbitrary array of stoichiometric
+    # transitions. Behaves like +#S_for+ method, with the difference that the
+    # rows correspond to _all_ places, not just free places.
+    # 
+    def stoichiometry_matrix_for( stoichiometric_transitions )
+      stoichiometric_transitions.map { |t| sparse_stoichiometry_vector t }
+        .reduce( Matrix.empty( places.size, 0 ), :join_right )
+    end
+
+    # Stoichiometry matrix of this simulation. By calling this method, the
+    # caller asserts, that all transitions in this simulation are SR transitions
+    # (or error).
+    # 
+    def S
+      return S_SR() if s_transitions.empty? && r_transitions.empty?
+      raise "The simulation contains also non-stoichiometric transitions! " +
+        "Consider using #S_for_SR."
+    end
+
+    # ==== ts transitions
+
+    # Returns the simulation's *ts* transitions, with syntax options like
+    # #transitions method.
+    # 
+    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 in the output, names are used instead
+    # of instances when 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
+
+    # Returns the simulation's *non-assignment* *ts* transtitions, with syntax
+    # options like #transitions method. While *A* transitions can be regarded
+    # as a special kind of *ts* transitions, it may often be useful to separate
+    # them out from the collection of "ordinary" *ts* transtitions (*tsa*
+    # 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 in the output, names are used instead
+    # of instances when 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
+
+    # ==== tS transitions
+
+    # Returns the simulation's *tS* transitions, with syntax options like
+    # #transitions method.
+    # 
+    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 in the output, names are used instead
+    # of instances when 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
+
+    # ==== Tsr transitions
+
+    # Returns the simulation's *Tsr* transitions, with syntax options like
+    # #transitions method.
+    # 
+    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 in the output, names are used instead
+    # of instances when 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
+
+    # ==== TSr transitions
+
+    # Returns the simulation's *TSr* transitions, with syntax options like
+    # #transitions method.
+    # 
+    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 in the output, names are used instead
+    # of instances when 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
+
+    # ==== sR transitions
+
+    # Returns the simulation's *sR* transitions, with syntax options like
+    # #transitions method.
+    # 
+    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 in the output, names are used instead
+    # of instances when 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
+
+    # ==== SR transitions
+
+    # Returns the simulation's *SR* transitions, with syntax options like
+    # #transitions method.
+    # 
+    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 in the output, names are used instead
+    # of instances when 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
+
+    # Returns the simulation's *A* transitions, with syntax options like
+    # #transitions method.
+    # 
+    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 in the output, names are used instead
+    # of instances when 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 arbitrary type (S transitions)
+
+    # Returns the simulation's *S* transitions, with syntax options like
+    # #transitions method.
+    # 
+    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 in the output, names are used instead
+    # of instances when 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 arbitrary type (s transitions)
+
+    # Returns the simulation's *s* transitions, with syntax options like
+    # #transitions method.
+    # 
+    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 in the output, names are used instead
+    # of instances when 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 of arbitrary type (R transitions)
+
+    # Returns the simulation's *R* transitions, with syntax options like
+    # #transitions method.
+    # 
+    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 in the output, names are used instead
+    # of instances when 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 of arbitrary type (r transitions)
+
+    # Returns the simulation's *r* transitions, with syntax options like
+    # #transitions method.
+    # 
+    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
+
+    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
+  end # module Collections
+end # class YPetri::Simulation