y_petri 2.3.12 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3fe2aaae8033f7806b851cd4293f555d15beb5a5
-  data.tar.gz: 79271fa571273448d6716b547785f66805b5d5b4
+  metadata.gz: ef666cef4bef63ff531f923b5b5c15dbf44f3d01
+  data.tar.gz: 39b9e0478d5fbe58ea0f351d930c307acdeab419
 SHA512:
-  metadata.gz: 14a6aba15f89a662ee2e13e16dc09695c1d00ccbe60ce7f969b9ae2a348f9bc8c98f51a2090643671b568d06f36419d162dda8ef5005fd34f014ec28aa75a855
-  data.tar.gz: 66681f89b12fc840eabc2d225af8e137492870c61c8d844b8fcb73cd78ef712bfe46c497882be534a98e5287bb76e7aa97a726f032bd16346cb79a735d4069e9
+  metadata.gz: c8c52cbb6efd249b118a8e9347a478725d2916354c894a63b1ef6da8bc7e517f0af702a0479cc39b3ee334b0579d697ce7926fb2e2de03850c8707aaeebea457
+  data.tar.gz: 8a3ed7e54e271be653a563401abeeebb8409e5c34b76eeba6f8ccc49af59c9e86d3427917840ae0adbab28f4c4f93d92e318acb8776a313ff4f915f856081bad

data/lib/y_petri/core/timed/runge_kutta.rb

@@ -3,57 +3,111 @@
 # Runge-Kutta method. Like vanilla Euler method, assumes that only T transitions are in the net.
 # 
 module YPetri::Core::Timed::RungeKutta
+  # Computes delta by Runge-Kutta 4th order method.
+  # 
   def delta Δt
     # The f below is from the equation state' = f( state )
-    f = lambda { |mv| # mv is the marking vector of the free places
-          result = "make hash from free places of the simulation to zeros"
-          nonstoichiometric_transitions.each { |t|
-            places = t.codomain.free
-            inputs = mv.select( t.domain ) # this doesn't work this way
-            f = t.function
-            output = f.call( *inputs )
-            places.each { |p|
-              result[p] += output[p] # again, this doesn't work this way
-            }
-          }
-          stoichiometric_transitions.each { |t|
-            places = t.codomain.free
-            inputs = mv.select( t.domain ) # this doesn't work this way
-            f = t.function
-            output = f.call( *inputs ) * stoichiometry_vector # this doesn't work this way
-            places.each { |p|
-              result[p] += output[p]
-            }
-          }
-          # so you see how many selections one has to do if one doesn't
-          # construct a specific gadget for the operation, that's why
-          # I made those closures, unfortunately I didn't think about
-          # higher-order methods yet when making them, and maybe the core
-          # should own them instead of the simulation object
-          
-          return result.to_vector # this doesn't work this way
-    }
-
-    # this is supposed to be Runge-Kutta 4th order
-    # but how do I get those in-between f values...
-    
-    y = simulation.state # this must return a vector compatible with the one
-                         # returned by f
-    
-    k1 = f( y )
-    k2 = f( y + Δt / 2 * k1 )
-    k3 = f( y + Δt / 2 * k2 )
-    k4 = f( y + Δt * k3 )
-
-    rslt = Δt / 6 * ( k1 + 2 * k2 + 2 * k3 + k4 )
-    return rslt.to_the_kind_of_vector_that_delta_method_should_return
-    # which is the vector corresponding to the ordered list of
-    # free places of this simulation (here, every core either has a
-    # simulation assigned, or is parametrized with simulation, which
-    # might be dumb anyway, since core, by its name, should not be that
-    # heavily coupled with a simulation, but actually, atm, each core
-    # belongs to a specific simulation, so it's OK if it's parametrized
-    # with it for now
+    f = lambda do |mv| # mv is the marking vector of the free places
+      # Delta from s transitions.
+      # TODO: This is only array now. Make it something else. One possibility
+      # would be to use simulation's MarkingVector class, but core should
+      # actually have its own marking vector class, probably parametrized by
+      # the net. It does not matter because alone I won't be able to exhaust
+      # all the possibilities.
+      delta_s = simulation.MarkingVector.zero( simulation.free_pp )
+      # Here, we get the nonstoichiometric transitions of the simulation.
+      nonstoichio_tt = simulation.s_tt
+      # Now, let's get the delta contribution of the nonstoichio. tt.
+      nonstoichio_tt.each { |t|
+        domain, codomain = t.domain, t.codomain # transition's domain
+        function = t.rate_closure # transition's function
+        output = Array function.call( *domain.map { |p| mv.fetch p } )
+        codomain.each_with_index do |p, i|
+          delta_s.set( p, delta_s.fetch( p ) + output[i] )
+        end
+        # TODO: The above code is suboptimal, needlessly computing
+        # MarkingVector#index and #fetch( place ) each time.
+        # The array incrementing might not be the best choice either,
+        # and most of all, the whole thing would need to be compiled
+        # into assembly language or at least FORTRAN.
+      }
+
+      # Delta from S transitions.
+      # TODO: (Same remark as for s transitions, see above.)
+      delta_S = simulation.MarkingVector.zero( simulation.free_pp )
+      # Here, we get the stoichiometric transitions of the simulation
+      stoichio_tt = simulation.S_tt
+      # Now, let's get the delta contribution of the stoichio. tt.
+      stoichio_tt.each { |t|
+        domain, codomain = t.domain, t.codomain # transition's domain
+        function = t.rate_closure # transition's function
+        s = t.stoichiometry
+        flux = function.call( *domain.map { |place| mv.fetch place } )
+        codomain.each_with_index do |p, i|
+          delta_S.set( p, delta_S.fetch( p ) + flux * s[i] )
+        end
+        # TODO: Again, the above code is suboptimal.
+      }
+
+      return delta_s + delta_S
+    end
+
+    y = marking_of_free_places
+
+    k1 = f.( y ) # puts "k1 ( = f( y ) ) is #{k1}"
+    k2 = f.( y + Δt / 2 * k1 ) # puts "k2 is #{k2}"
+    k3 = f.( y + Δt / 2 * k2 ) # puts "k3 is #{k3}"
+    k4 = f.( y + Δt * k3 ) # puts "k4 is #{k4}"
+
+    rslt = Δt / 6 * ( k1 + 2 * k2 + 2 * k3 + k4 ) # puts "rslt is #{rslt}"
+
+    return rslt                 # Marking vector of free places
   end
   alias Δ delta
+
+  def step! Δt=simulation.step
+    # TODO: Thus far, runge_kutta method is an exception in the core in
+    # that it works with core's own state. (Core used to work with
+    # simulation's state before and rely on the simulation to provide
+    # state increment and assign closures.) This is how whole core should
+    # work.
+    increment_marking_of_free_places Δ( Δt )
+    increment_time! Δt
+    alert_user! marking_of_free_places
+  end
+
+  def increment_marking_of_free_places by
+    # TODO: Same remark as above.
+    @marking_of_free_places += by
+  end
+
+  def increment_time! by
+    # TODO: Once other timed methods than runge_kutta are reasonable, this
+    # should be moved to core/timed.rb
+    @time += by
+  end
+
+  def reset_time! to=0.0
+    # TODO: Once other timed methods than runge_kutta are reasonable, this
+    # should be moved to core/timed.rb
+    @time = to
+  end
+
+  def set_user_alert_closure &block
+    # TODO: Core's runge_kutta method is special for now, and even
+    # simulation recognizes that. With runge_kutta method, core uses
+    # single @user_alert_closure which it calls whenever the state
+    # of the core progresses. It is the business of the user to supply,
+    # before using the core, that does what the user wants. It is also
+    # imaginable that different core's modes of operation would have
+    # different sensitivity with regard to alerting the user, but for now,
+    # the user is alerted whenever anything happens at all.
+    @user_alert_closure = block
+  end
+
+  def alert_user! object
+    # TODO: As soon as more core's method begin relying on core's own state,
+    # this method will be moved to Core module.
+    @user_alert_closure.call( object )
+  end
 end # YPetri::Core::Timed::RungeKutta

data/lib/y_petri/core/timed.rb

@@ -5,9 +5,9 @@
 # 
 class YPetri::Core::Timed
   ★ YPetri::Core
-  
+
   require_relative 'timed/basic'
-  require_relative 'timed/ticked'       # 
+  require_relative 'timed/ticked'
   require_relative 'timed/euler'
   require_relative 'timed/runge_kutta'
   require_relative 'timed/gillespie'
@@ -20,20 +20,38 @@ class YPetri::Core::Timed
     gillespie: Gillespie        # for timed nets only
   }
 
+  # From now on, core has its own time attribute and selector.
+  attr_reader :time
+
+  # This inquirer (=Boolean selector) is always true for timed cores.
+  # 
+  def timed?; true end
+
+  # This inquirer (=Boolean selector) is always false for timed cores.
+  # 
+  def timeless?; false end
+
   def initialize **named_args
-    super
+    super                       # TODO: Net type checking.
+    @time = 0.0
     extend METHODS.fetch simulation_method
-    # look in the Core#initialize method for the closures and parameters
-    # and such. Here, we could define:
-    @Ts_gradient_closure = simulation.Ts_gradient_closure
-    # which would remind us that this machine needs to be
-    # actually defined internal to Core instance
+    @delta_s = simulation.MarkingVector.zero( @free_pp )
+    @delta_S = simulation.MarkingVector.zero( @free_pp )
+  end
+
+  # Increments core time by Δt.
+  # 
+  def increment_time! Δt
+    @time += Δt
   end
 
   # Makes a single step by Δt.
   # 
   def step! Δt=simulation.step
+    # TODO: This one will act directly upon simulation. Subject of potential
+    # change later.
     increment_marking_vector Δ( Δt )
+    # TODO: The bottom two, obviously, act directly upon simulation.
     simulation.increment_time! Δt
     simulation.recorder.alert
   end

data/lib/y_petri/core/timeless.rb

@@ -12,6 +12,14 @@ class YPetri::Core::Timeless
   # Note: the reason why Timeless core has distinct basic method is because
   # without having to consider timed transitions, it can be made simpler.
 
+  # This inquirer (=Boolean selector) is always false for timeless cores.
+  # 
+  def timed?; false end
+
+  # This inquirer (=Boolean selector) is always true for timeless cores.
+  # 
+  def timeless?; true end
+
   def initialize **named_args
     super
     extend METHODS.fetch simulation_method

data/lib/y_petri/core.rb

@@ -11,58 +11,69 @@ module YPetri::Core
 
   DEFAULT_METHOD = :basic
 
-  # I'm doing it this way in order to gradually begin decoupling in my mind
-  # core from simulation. The constructed core will have to be assigned the
-  # simulation object on which it will depend before core is made completely
-  # independend on simulation. (Not gonna happen any soon.)
-  # 
+  # Instead of getting the parametrized subclass of Timed/Timeless core
+  # belonging to a simulation, I am passing a simulation instance to the
+  # constructor now in order to gradually begin decoupling in my mind core
+  # simulation. If I ever make the core independent from the simulation,
+  # it will have its own representation of the net and its own capability
+  # to form wiring and apply the required numerical procedures.
+
   attr_reader :simulation         # just a remark:
   attr_reader :simulation_method  # "reader" is "selector" in Landin's language
+  attr_reader :guarded
+  alias guarded? guarded
+
+  attr_reader :free_pp,
+              :clamped_pp,
+              :pp,
+              :marking_of_free_places,
+              :marking_of_clamped_places
 
   def initialize simulation: nil, method: nil, guarded: false, **named_args
     @simulation = simulation or fail ArgumentError, "Core requires simulation!"
     @simulation_method = method || DEFAULT_METHOD
-    
+
     if guarded then            # TODO: Guarded is unfinished business.
       fail NotImplementedMethod, "Guarded core is not implemented yet!"
       require_relative 'core/guarded' # TODO: Should be replaced with autoload.
     else @guarded = false end
-    
-    # Dependent on Simulation, this machine returns "delta contribution for ts
-    # (timeless nonstoichiometric) transitions", which smells like a vector of
-    # size corresponding to the number of free places.
-    # 
-    @delta_closure_for_ts_transitions = simulation.ts_delta_closure
-
-    # This one is slightly different in that it returns so-called "firing vector",
-    # from which delta vector is computed by multiplying it with tS stoichiometry
-    # matrix.
-    # 
-    @firing_closure_for_tS_transitions = simulation.tS_firing_closure
-
-    # This machine is special in that it directly modifies the marking vector,
-    # firing the assignment transitions one by one (or so I think).
-    # 
-    @assignment_closure_for_A_transitions = simulation.A_direct_assignment_closure
-
-    # We're gonna change all of the above. The marking vectors will be owned by
-    # the core now. Machines will be wired only inside the core.
+
+    @free_pp = simulation.free_pp
+    @clamped_pp = simulation.clamped_pp
+    @pp = simulation.pp
+    # TODO: Try to make the lines below simpler. In particular, in the future, core should
+    # not depend on simulation at this level.
+    @marking_of_free_places = simulation.MarkingVector.starting( @free_pp )
+    @marking_of_clamped_places = simulation.MarkingVector.starting( @clamped_pp )
+
+    # TODO: I don't remember how to load this in a simple way.
+    simulation.state.to_hash.each do |place, value|
+      if @marking_of_free_places.annotation.include? place then
+        @marking_of_free_places.set( place, value )
+      elsif @marking_of_clamped_places.annotation.include? place then
+        @marking_of_clamped_places.set( place, value )
+      else
+        fail "Problem loading marking vector to timed core."
+      end
+    end
   end
 
-  # TODO: this delegation below is not completely right.
-  # 1. There is no subclassing and Timed/Timeless module inclusion, so there
-  # is no need to delegate timed?/timeless? to the class, if only the modules
-  # provide those inquirer methods (predicates in Landin's language).
-  # 2. Same goes for guarded? predicate, which might be the business of
-  # Core::Guarded module (or not)
-  # 
-  delegate :timed?,
-           :timeless?,
-           :guarded?,
-           to: "self.class"
+  # Selector of the core's own state vector.
+  #
+  def state
+    # TODO: Make it more efficient. Later, when core is detached from
+    # simulation, use own assets instead of simulation.MarkingVector
+    simulation.MarkingVector.zero.tap do |mv|
+      @marking_of_free_places.annotation.each do |place|
+        mv.set place, @marking_of_free_places.fetch( place )
+      end
+      @marking_of_clamped_places.annotation.each do |place|
+        mv.set place, @marking_of_clamped_places.fetch( place )
+      end
+    end
+  end
 
-  delegate :alert!,
-           to: :recorder
+  delegate :alert!, to: :recorder
 
   # Delta for free places from timeless transitions.
   # 
@@ -148,4 +159,3 @@ end # module YPetri::Core
 # deterministic (continous) and stochastic (discrete, going quantum by
 # quantum, or by several quanta, there is more than one stochastic discrete
 # method in stock) methods for simulation of individual processes.
-

data/lib/y_petri/simulation/dependency.rb

@@ -1,18 +1,18 @@
 # encoding: utf-8
 
 # Mixin providing collections of places / transitions to classes parametrized
-# by an instance of YPetri::Simulation. Expects the includer classes to provide
-# +#simulation+ method returning the +Simulation+ instance with which they are
-# parametrized.
+# by an instance of +YPetri::Simulation+. Expects the includer classes to
+# provide +#simulation+ method returning the +Simulation+ instance with which
+# they are parametrized.
 # 
 class YPetri::Simulation
   module Dependency
-    delegate :Place,
-             :Transition,
+    delegate :PlacePS,
+             :TransitionPS,
              :MarkingClamp,
              :InitialMarkingObject,
-             :Places,
-             :Transitions,
+             :PlacesPS,
+             :TransitionsPS,
              :MarkingClamps,
              :InitialMarking,
              :net,
@@ -37,7 +37,7 @@ class YPetri::Simulation
         end
       end
     end
-    
+
     # Necessary to overcome the protected character of the listed methods.
     # 
     [ :node,

data/lib/y_petri/simulation/marking_vector.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 class YPetri::Simulation
-  # The class in which places' marking is stored insid a simulation.
+  # The class in which places' marking is stored inside a simulation.
   #
   class MarkingVector < Matrix
     ★ Dependency
@@ -14,6 +14,12 @@ class YPetri::Simulation
       # Constructs a marking vector from a hash places >> values, or from
       # an array, in which case, it is assumed that the marking vector
       # corresponds to all the places in the simulation.
+      #
+      # TODO: I don't like having to write MarkingVector[ [ 1, 2, 3 ] ] instead
+      # of MarkingVector[ 1, 2, 3 ], but I accepted and endorsed it long time
+      # ago as a necessary tax for being able to distinguish between the user
+      # meaning to supply no arguments and the user meaning to supply empty
+      # vector.
       # 
       def [] arg
         case arg
@@ -25,10 +31,10 @@ class YPetri::Simulation
               msg unless arg.size == annotation.size
             column_vector( arg )
           else
-            annotated_with( places )[ args ]
+            annotated_with( places )[ arg ]
           end
         else
-          self[ args.each.to_a ]
+          self[ arg.each.to_a ]
         end
       end
 
@@ -46,7 +52,7 @@ class YPetri::Simulation
       # 
       def starting places=nil
         if places.nil? then
-          return starting places() if annotation.nil?
+          return starting( places() ) if annotation.nil?
           self[ annotation.map { |p| p.free? ? p.initial_marking : p.clamp } ]
         else
           annotated_with( places ).starting
@@ -80,7 +86,7 @@ class YPetri::Simulation
       end
     end
 
-    # Modifying the vector nodes.
+    # Modifying the vector elements.
     # 
     def set id, value
       self[ index( id ), 0 ] = value
@@ -92,17 +98,25 @@ class YPetri::Simulation
     def reset! arg=self.class.starting
       case arg
       when Hash then
+        # Hash is first converted into a PlaceMapping instance (mp).
         mp = simulation.PlaceMapping().load( arg )
+        # Updated marking vector is constructed using reliable methods
+        # self.class.starting and self#set.
         updated = mp.each_with_object self.class.starting do |(place, value), mv|
           mv.set place, value
         end
+        # Updated marking vector is then converted into an array and #reset! method
+        # is called upon it again to actually perform in-place update of this vector.
+        # TODO: The above is slightly inefficient -- constructing a new vector when
+        # in-place modification seems a better solution. But if it works, it's a
+        # strong reason to not fix it until we are in the optimization stage.
         reset! updated.column_to_a
       else # array arg assumed
         arg.each.to_a.zip( annotation ).map { |value, place| set place, value }
       end
     end
 
-    # Access of the vector nodes.
+    # Access of the vector elements.
     # 
     def fetch id
       self[ index( id ), 0  ]

data/lib/y_petri/simulation/matrix.rb

@@ -39,7 +39,7 @@ class Matrix
       end
       code_lines.compact.join( "\n" ) << "\n"
     end
-    
+
     # Builds a code string for incrementing a vector at given indices. Source is
     # an array.
     # 
@@ -63,4 +63,14 @@ class Matrix
                                                indices: indices,
                                                source: "delta" )
   end
+
+  # Builds a closure for assigning to a column at given indices.
+  #
+  def assign_at_indices_closure indices: (fail ArgumentError, "No indices!")
+    v = self
+    eval "-> ass do\n%s\nend" %
+      self.class.column_vector_assignment_code( vector: ?v,
+                                                indices: indices,
+                                                source: "ass" )
+  end
 end

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

@@ -62,7 +62,7 @@ class YPetri::Simulation::Nodes
       # NOTE: At the moment, the Simulation instance does not have a
       # parametrized subclass of Simulation::Nodes class, the following
       # statement is thus made to return a plain array of elements.
-      Nodes().load array.map &method( :node )
+      NodesPS().load array.map &method( :node )
     end
 
     # Without arguments, returns all the nodes (places / transitions) of the

data/lib/y_petri/simulation/nodes.rb

@@ -5,7 +5,7 @@ class YPetri::Simulation
   # 
   class Nodes < Array
     ★ Dependency
-    
+
     class << self
       # New collection constructor
       # 
@@ -13,15 +13,15 @@ class YPetri::Simulation
         new.tap { |inst| inst.load collection }
       end
     end
-    
+
     delegate :simulation, to: "self.class"
-    
+
     # Loads nodes to this collection.
     # 
     def load nodes
       nodes.each{ |node| push node }
     end
-    
+
     # Creates a subset of this collection (of the same class).
     # 
     def subset nodes=nil, &block # TODO: Rename to subarray
@@ -37,7 +37,7 @@ class YPetri::Simulation
         self.class.load( nn )
       end
     end
-    
+
     # Returns an array of the node sources (nodes in the underlying net).
     # 
     def sources

data/lib/y_petri/simulation/place_mapping.rb

@@ -26,7 +26,7 @@ class YPetri::Simulation
     # Returns the initial marking as a column vector.
     # 
     def vector
-      simulation.MarkingVector[ self ]
+      simulation.MarkingVector[ *self ]
     end
     alias to_marking_vector vector
 
@@ -60,5 +60,5 @@ class YPetri::Simulation
     def keys_to_source_places
       with_keys do |key| key.source end
     end
-  end # class InitialMarking
+  end # class PlaceMapping
 end # class YPetri::Simulation

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

@@ -66,11 +66,11 @@ class YPetri::Simulation::Places
     # Place instance identification.
     # 
     def place( place )
-      begin; Place().instance( place ); rescue NameError, TypeError
+      begin; PlacePS().instance( place ); rescue NameError, TypeError
         begin
           place = net.place( place )
           places.find { |place_rep| place_rep.source == place } ||
-            Place().instance( place.name )
+            PlacePS().instance( place.name )
         rescue NameError, TypeError => msg
           raise # FIXME: This raise needs to be here in order for the current
           # tests to pass (they expect NameError, while the raise below would
@@ -89,16 +89,17 @@ class YPetri::Simulation::Places
     # that even without an argument, it does not fail, but returns the @Places
     # parametrized subclass itself.
     # 
-    def Places( array ) # TODO: Understand why this method does not behave
-                        # as protected in real Simulation instances, while
-                        # places method just above does.
+    def Places( array )
       # Kernel.p array
-      Places().load array.map &method( :place )
+      PlacesPS().load array.map &method( :place )
     end
 
-    # Without arguments, returns all the place representations in the simulation.
-    # Otherwise, it accepts an arbitrary number of places or place ids as
-    # arguments, and a corresponding array of place representations.
+    # This method is overloaded in such way, that when called without arguments,
+    # it acts as a selector of @places property (instance variable) of the
+    # simulation. When called with arguments, all the arguments must be places
+    # or symbols (or strings etc.) identifying a place, and for these arguments,
+    # the method returns an array of corresponding places (more precisely,
+    # objects that represent places in the context of the receiver simulation).
     # 
     def places( *places )
       return @places if places.empty?

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

@@ -1,5 +1,8 @@
 # encoding: utf-8
 
+require_relative 'free'
+require_relative 'clamped'
+
 # A mixin with place type selectors.
 # 
 class YPetri::Simulation::Places
@@ -7,16 +10,16 @@ class YPetri::Simulation::Places
     # Subset of free places, if any.
     # 
     def free
-      ( @Type_free ||= Class.new( self.class ).tap do |klass|
-          klass.class_exec { include Type_free }
+      ( @Type_free ||= Class.new self.class do
+          include Type_free
         end ).load subset( &:free? )
     end
-    
+
     # Subset of clamped places, if any.
     # 
     def clamped
-      ( @Type_clamped ||= Class.new( self.class ).tap do |klass|
-          klass.class_exec { include Type_clamped }
+      ( @Type_clamped ||= Class.new self.class do
+          include Type_clamped
         end ).load subset( &:clamped? )
     end
   end # Types

data/lib/y_petri/simulation/places.rb

@@ -4,8 +4,6 @@
 #
 class YPetri::Simulation::Places < YPetri::Simulation::Nodes
   require_relative 'places/types'
-  require_relative 'places/free'
-  require_relative 'places/clamped'
 
   ★ Types
 
@@ -15,7 +13,7 @@ class YPetri::Simulation::Places < YPetri::Simulation::Nodes
     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 )
+    super p.name ? PlacePS().new( p, name: p.name ) : PlacePS().new( p )
   end
 
   # Marking of the place collection in the current simulation.