y_petri 2.0.15 → 2.1.3

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

@@ -0,0 +1,45 @@
+#encoding: utf-8
+
+# A mixin for S transition representations.
+# 
+class YPetri::Simulation::TransitionRepresentation
+  module Type_S
+    include Type_a
+    
+    attr_reader :stoichiometry
+    
+    # Sparse stoichiometry vector corresponding to the free places.
+    # 
+    attr_reader :sparse_stoichiometry_vector
+    
+    # Sparse stoichiometry vector corresponding to all the places.
+    # 
+    attr_reader :sparse_sv
+    
+    # True for stoichiometric transitions.
+    # 
+    def S?
+      true
+    end
+    alias stoichiometric? S?
+    
+    # False for stoichiometric transitions.
+    # 
+    def s?
+      false
+    end
+    alias nonstoichiometric? s?
+    
+    # Initialization subroutine.
+    # 
+    def init
+      super
+      @stoichiometry = source.stoichiometry
+      @sparse_stoichiometry_vector =
+        Matrix.correspondence_matrix( codomain, free_places ) *
+        stoichiometry.to_column_vector
+      @sparse_sv = Matrix.correspondence_matrix( codomain, places ) *
+        stoichiometry.to_column_vector
+    end
+  end # module Type_S
+end # class YPetri::Simulation::TransitionRepresentation

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

@@ -0,0 +1,80 @@
+#encoding: utf-8
+
+# A mixin for timed transition representations.
+# 
+class YPetri::Simulation::TransitionRepresentation
+  module Type_T
+    include Type_a
+    
+    # True for timed transitions.
+    # 
+    def T?
+      true
+    end
+    alias timed? T?
+    
+    # False for timed transitions.
+    # 
+    def t?
+      false
+    end
+    alias timeless? t?
+    
+    # Initialization subroutine.
+    # 
+    def init
+      simulation.extend YPetri::Simulation::Timed unless simulation.timed?
+      super
+      @function = source.rate_closure
+    end
+    
+    # Gradient contribution of the transition to the free places.
+    # 
+    def gradient
+      ∇.select { |p, v| p.free? }
+    end
+    
+    # Returns the gradient contribution to the free places, as hash
+    # place names >> gradient contribution.
+    # 
+    def g
+      gradient.with_keys do |p| p.name || p end
+    end
+    
+    # Returns the gradient contribution to all the places, as hash
+    # place names >> gradient contribution.
+    # 
+    def g_all
+      ∇.with_keys do |p| p.name || p end
+    end
+    
+    # Change, for free places, as it would happen if the transition fired for
+    # time Δt, returned as hash codomain places >> change.
+    # 
+    def delta Δt
+      gradient.with_values { |v| v * Δt }
+    end
+    
+    # Change, for free places, as it would happen if the transition fired for
+    # time Δt, returned as hash codomain place names >> change.
+    # 
+    def d Δt
+      delta( Δt ).with_keys do |p| p.name || p end
+    end
+    
+    # Change, for all places, as it would happen if the transition fired for
+    # time Δt, returned as hash codomain places >> change.
+    # 
+    def Δ( Δt )
+      gradient.with_values { |v| v * Δt }
+    end
+    alias delta_all Δ
+    
+    # Change, for all places, as it would happen if the transition fired for
+    # time Δt, returned as hash codomain place names >> change.
+    # 
+    def d_all( Δt )
+      delta( Δt ).with_keys do |p| p.name || p end
+    end
+  end # Type_T
+end # class YPetri::Simulation::TransitionRepresentation

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

@@ -0,0 +1,46 @@
+#encoding: utf-8
+
+# A mixin for TS transition representations.
+# 
+class YPetri::Simulation::TransitionRepresentation
+  module Type_TS
+    include Type_T
+    include Type_S
+    
+    attr_reader :rate_closure
+    
+    # Initialization subroutine.
+    # 
+    def init
+      super
+      @rate_closure = to_rate_closure
+    end
+    
+    # Transition's rate, given the current system state.
+    # 
+    def rate
+      rate_closure.call
+    end
+    alias flux rate
+    alias propensity rate
+    
+    # Firing of the transition (rate * Δtime).
+    # 
+    def firing Δt
+      rate * Δt
+    end
+    
+    # Gradient contribution of the transition to all places.
+    # 
+    def ∇
+      codomain >> stoichiometry.map { |coeff| rate * coeff }
+    end
+    alias gradient_all ∇
+    
+    # Builds a flux closure.
+    # 
+    def to_rate_closure
+      build_closure
+    end
+  end # module Type_TS
+end # class YPetri::Simulation::TransitionRepresentation

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

@@ -0,0 +1,32 @@
+#encoding: utf-8
+
+# A mixin for Ts transition representations.
+# 
+class YPetri::Simulation::TransitionRepresentation
+  module Type_Ts
+    include Type_T
+    include Type_s
+    
+    attr_reader :gradient_closure
+    
+    # Initialization subroutine.
+    # 
+    def init
+      super
+      @gradient_closure = to_gradient_closure
+    end
+    
+    # Gradient contribution of the transition to all places.
+    # 
+    def ∇
+      codomain >> gradient_closure.call
+    end
+    alias gradient_all ∇
+    
+    # Builds a gradient closure.
+    # 
+    def to_gradient_closure
+      build_closure
+    end
+  end # Type_Ts
+end # class YPetri::Simulation::TransitionRepresentation

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

@@ -0,0 +1,30 @@
+#encoding: utf-8
+
+# A mixin for non-assignment transition representations.
+# 
+module YPetri::Simulation::TransitionRepresentation::Type_a
+  # Assignment action -- false for non-assignment transitions.
+  # 
+  def A?
+    false
+  end
+  alias assignment_action? A?
+  alias assignment? A?
+
+  # Normal (non-assignment) action -- true for A transitions
+  # 
+  def a?
+    true
+  end
+
+  # Initialization subroutine.
+  # 
+  def init
+  end
+
+  # Change, for free places, as it would happen if the transition fired.
+  # 
+  def delta
+    Δ.select { |p, v| p.free? }
+  end
+end # class YPetri::Simulation::TransitionRepresentation::Type_a

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

@@ -0,0 +1,29 @@
+#encoding: utf-8
+
+# A mixin for s (nonstoichiometric) transition representations.
+# 
+class YPetri::Simulation::TransitionRepresentation
+  module Type_s
+    include Type_a
+    
+    # False for non-stoichiometric transitions.
+    # 
+    def S?
+      false
+    end
+    alias stoichiometric? S?
+    
+    # True for stoichiometric transitions.
+    # 
+    def s?
+      true
+    end
+    alias nonstoichiometric? s?
+    
+    # Initialization subroutine.
+    # 
+    def init
+      super
+    end
+  end # module Type_s
+end # class YPetri::Simulation::TransitionRepresentation

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

@@ -0,0 +1,37 @@
+#encoding: utf-8
+
+# A mixin for timed transition representations.
+# 
+class YPetri::Simulation::TransitionRepresentation
+  module Type_t
+    include Type_a
+    
+    # False for timed transitions.
+    # 
+    def T?
+      false
+    end
+    alias timed? T?
+    
+    # True for timed transitions.
+    # 
+    def t?
+      true
+    end
+    alias timeless? t?
+    
+    # Initialization subroutine.
+    # 
+    def init
+      super
+      @function = source.action_closure
+    end
+    
+    # Change, as it would happen if the transition fired, returned as hash
+    # codomain places >> change.
+    # 
+    def d
+      delta.with_keys do |p| p.name || p end
+    end
+  end # Type_t
+end # class YPetri::Simulation::TransitionRepresentation

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

@@ -0,0 +1,38 @@
+#encoding: utf-8
+
+# A mixin for tS transition representations.
+# 
+class YPetri::Simulation::TransitionRepresentation
+  module Type_tS
+    include Type_t
+    include Type_S
+    
+    attr_reader :firing_closure
+    
+    # Initialization subroutine.
+    # 
+    def init
+      super
+      @firing_closure = to_firing_closure
+    end
+    
+    # Transition's firing, given the current system state.
+    # 
+    def firing
+      firing_closure.call
+    end
+    
+    # Change, to all places, as it would happen if the transition fired.
+    # 
+    def Δ
+      codomain >> stoichiometry.map { |coeff| firing * coeff }
+    end
+    alias delta_all Δ
+    
+    # Builds a firing closure.
+    # 
+    def to_firing_closure
+      build_closure
+    end
+  end # module Type_tS
+end # class YPetri::Simulation::TransitionRepresentation

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

@@ -0,0 +1,32 @@
+#encoding: utf-8
+
+# A mixin for ts transition representations.
+# 
+class YPetri::Simulation::TransitionRepresentation
+  module Type_ts
+    include Type_t
+    include Type_s
+
+    attr_reader :delta_closure
+
+    # Initialization subroutine.
+    # 
+    def init
+      super
+      @delta_closure = to_delta_closure
+    end
+
+    # Delta state closure.
+    # 
+    def to_delta_closure
+      build_closure
+    end
+
+    # Change, to all places, as it would happen if the transition fired.
+    # 
+    def Δ
+      codomain >> delta_closure.call
+    end
+    alias delta_all Δ
+  end # module Type_ts
+end # class YPetri::Simulation::TransitionRepresentation

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

@@ -0,0 +1,62 @@
+#encoding: utf-8
+
+require_relative 'a'
+require_relative 'A'
+require_relative 't'
+require_relative 'T'
+require_relative 's'
+require_relative 'S'
+require_relative 'ts'
+require_relative 'Ts'
+require_relative 'tS'
+require_relative 'TS'
+
+# A mixin with transition types.
+# 
+class YPetri::Simulation::TransitionRepresentation
+  module Types
+    attr_reader :type
+
+    def type_init *args
+      extend case source.type
+             when :A then Type_A
+             when :TS then Type_TS
+             when :Ts then Type_Ts
+             when :tS then Type_tS
+             when :ts then Type_ts
+             else fail TypeError, "Unknown tr. type #{source.type}!" end
+      init
+    end
+    
+    # The transition's type.
+    # 
+    def type
+      return :A if A?
+      if T? then S? ? :TS : :Ts else S? ? :tS : :ts end
+    end
+    
+    # Is this a TS transition?
+    # 
+    def TS?
+      type == :TS
+    end
+    
+    # Is this a Ts transition?
+    # 
+    def Ts?
+      type == :Ts
+    end
+    
+    # Is this a tS transition?
+    # 
+    def tS?
+      type == :tS
+    end
+    
+    # Is this a ts transition?
+    # 
+    def ts?
+      type == :ts
+    end
+  end # module Types
+end # class YPetri::Simulation::TransitionRepresentation

data/lib/y_petri/simulation/transition_representation.rb

@@ -0,0 +1,79 @@
+#encoding: utf-8
+
+# Representation of a YPetri::Transition inside a YPetri::Simulation instance.
+#
+class YPetri::Simulation
+  class TransitionRepresentation < ElementRepresentation
+    require_relative 'transition_representation/types'
+    include Types
+
+    attr_reader :domain, :codomain
+    attr_reader :function # source transition function
+
+    # Expect a single YPetri place as an argument.
+    # 
+    def initialize net_transition
+      super
+      @domain, @codomain = places( source.domain ), places( source.codomain )
+      type_init
+    end
+
+    # Returns the indices of this transition's domain in the marking vector.
+    # 
+    def domain_indices
+      domain.map { |p| places.index p }
+    end
+
+    # Returns the indices of this transition's codomain in the marking vector.
+    # 
+    def codomain_indices
+      codomain.map { |p| places.index p }
+    end
+
+    # Returns the indices of this transition's domain among the free places.
+    # 
+    def free_domain_indices
+      domain.map { |p| free_places.index p }
+    end
+
+    # Returns the indices of this transition's codomain among the free places.
+    # 
+    def free_codomain_indices
+      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.
+    # 
+    def domain_access_code( vector: :m_vector )
+      Matrix.column_vector_access_code( vector: vector,
+                                        indices: domain_indices )
+    end
+
+    # Builds a code string that assigns to the free places of the codomain.
+    # 
+    def codomain_assignment_code vector: (fail ArgumentError, "No vector!"),
+                                 source: (fail ArgumentError, "No source array!")
+      Matrix.column_vector_assignment_code( vector: vector,
+                                            indices: free_codomain_indices,
+                                            source: source )
+    end
+
+    # Builds a closure that increments a vector with this transition's codomain.
+    # 
+    def increment_by_codomain_code vector: (fail ArgumentError, "No vector!"),
+                                   source: (fail ArgumentError, "No source array!")
+      Matrix.column_vector_increment_by_array_code vector: vector,
+                                                   indices: free_codomain_indices,
+                                                   source: source
+    end
+  end # class TransitionRepresentation
+end # class YPetri::Simulation

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

@@ -0,0 +1,40 @@
+#encoding: utf-8
+
+# A mixin for collections of A transitions.
+# 
+class YPetri::Simulation::Transitions
+  module Type_A
+    attr_reader :assignment_closure
+    
+    def initialize
+      @assignment_closure = to_assignment_closure
+    end
+
+    # Assignment closures that directly affect the marking when called.
+    # 
+    def assignment_closures
+      map &:assignment_closure
+    end
+
+    # Combined assignment action, as it would occur if these A transitions fired
+    # in order, as hash place >> action.
+    # 
+    def action
+      each_with_object Hash.new do |t, hsh| hsh.update( t.action ) end
+    end
+
+    # Returns the assignments to all places, as they would happen if A transition
+    # could change their values.
+    # 
+    def act
+      each_with_object Hash.new do |t, hsh| hsh.update( t.act ) end
+    end
+
+    # Builds a joint assignment closure.
+    # 
+    def to_assignment_closure
+      closures = assignment_closures
+      -> { closures.each &:call }
+    end
+  end # Type_A
+end # class YPetri::Simulation::Transitions

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

@@ -0,0 +1,24 @@
+#encoding: utf-8
+
+# A mixin for collections of S transitions.
+# 
+class YPetri::Simulation::Transitions
+  module Type_S
+    include Type_a
+
+    # Returns the collection's stoichiometry matrix versus free places.
+    # 
+    def stoichiometry_matrix
+      map( &:sparse_stoichiometry_vector )
+        .reduce( Matrix.empty( places.free.size, 0 ), :join_right )
+    end
+
+    # Returns the collection's stoichiometry matrix versus all places.
+    # 
+    def SM
+      map( &:sparse_sv )
+        .reduce( Matrix.empty( places.size, 0 ), :join_right )
+    end
+    alias stoichiometry_matrix_all SM
+  end # module Type_S
+end # class YPetri::Simulation::Transitions

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

@@ -0,0 +1,34 @@
+#encoding: utf-8
+
+# A mixin for collections of T transitions.
+# 
+class YPetri::Simulation::Transitions
+  module Type_T
+    include Type_a
+
+    # T transitions have gradient closures.
+    # 
+    def gradient_closures
+      map &:gradient_closure
+    end
+
+    # Gradient by the T transitions.
+    # 
+    def gradient
+      Ts().gradient + TS().gradient
+    end
+
+    # State change of free places if the timed transitions fire for given time.
+    # 
+    def delta Δt
+      gradient * Δt
+    end
+
+    # State change of all places if the timed transitions fire for given time.
+    # 
+    def Δ Δt
+      ∇ * Δt
+    end
+    alias delta_all Δ
+  end # module Type_T
+end # class YPetri::Simulation::Transitions

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

@@ -0,0 +1,57 @@
+#encoding: utf-8
+
+# Mixin for collections of TS transitions.
+#
+class YPetri::Simulation::Transitions
+  module Type_TS
+    include Type_T
+    include Type_S
+
+    # Rate vector closure accessor.
+    # 
+    def rate_closure
+      @rate_closure ||= to_rate_closure
+    end
+
+    # Rate (flux, propensity) closures.
+    # 
+    def rate_closures
+      map &:rate_closure
+    end
+
+    # Rate (flux/propensity) vector.
+    # 
+    def rate_vector
+      to_rate_closure.call
+    end
+    alias flux_vector rate_vector
+    alias propensity_vector rate_vector
+
+    # Firing vector (rate vector * Δtime).
+    # 
+    def firing_vector Δt
+      rate_vector * Δt
+    end
+
+    # Gradient contribution to free places.
+    # 
+    def gradient
+      stoichiometry_matrix * rate_vector
+    end
+
+    # Gradient contribution to all places.
+    # 
+    def ∇
+      SM() * rate_vector
+    end
+    alias gradient_all ∇
+
+    # Builds the rate vector closure, that outputs the rate vector based on
+    # the system state when called.
+    # 
+    def to_rate_closure
+      rc = rate_closures
+      -> { rc.map( &:call ).to_column_vector }
+    end
+  end # module Type_TS
+end # class YPetri::Simulation::Transitions