y_petri 2.0.15 → 2.1.3

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

@@ -0,0 +1,60 @@
+#encoding: utf-8
+
+# A mixin for collections of Ts transitions.
+# 
+class YPetri::Simulation::Transitions
+  module Type_Ts
+    include Type_T
+    include Type_s
+
+    # gradient closure accessor.
+    # 
+    def gradient_closure
+      @gradient_closure ||= to_gradient_closure
+    end
+
+    # Member gradient closures.
+    # 
+    def gradient_closures
+      map &:gradient_closure
+    end
+
+    # Gradient contribution for free places.
+    # 
+    def gradient
+      gradient_closure.call
+    end
+
+    # Gradient contribution to all places.
+    # 
+    def ∇
+      f2a * gradient
+    end
+    alias gradient_all ∇
+
+    # Constructs a gradient closure that outputs a gradient vector corresponding
+    # to free places. The vector is the gradient contribution of the transitions
+    # in this collection.
+    # 
+    def to_gradient_closure
+      fp = free_places
+      closures = gradient_closures
+      sMV = simulation.MarkingVector
+      stu = simulation.time_unit
+
+      code_sections = map.with_index do |t, i|
+        "a = closures[ #{i} ].call\n" +
+          t.increment_by_codomain_code( vector: "g", source: "a" )
+      end
+      body = code_sections.join( "\n" )
+      λ = <<-LAMBDA
+        -> do
+        g = sMV.zero( fp ) / stu
+        #{body}
+        return g
+        end
+      LAMBDA
+      eval λ
+    end
+  end # module Type_Ts
+end # class YPetri::Simulation::Transitions

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

@@ -0,0 +1,8 @@
+#encoding: utf-8
+
+# A mixin for collections of A transitions.
+# 
+class YPetri::Simulation::Transitions
+  module Type_a
+  end # Type_a
+end # class YPetri::Simulation::Transitions

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

@@ -0,0 +1,186 @@
+#encoding: utf-8
+
+# Simulation mixin providing access to transitions.
+#
+class YPetri::Simulation::Transitions
+  module Access
+    # Does a transition belong to the simulation?
+    # 
+    def includes_transition?( id )
+      true.tap { begin; transition( id )
+                 rescue NameError, TypeError
+                   return false
+                 end }
+    end
+    alias include_transition? includes_transition?
+
+    # Transition of the simulation (belonging to the net).
+    # 
+    def t( id )
+      transitions( id ).source
+    end
+
+    # Transitions of the simulation (belonging to the net).
+    # 
+    def tt( ids=nil )
+      transitions( ids ).sources
+    end
+
+    # Free places of the simulation (belonging to the net).
+    # 
+    def ts_tt( ids=nil )
+      ts_transitions( ids ).sources
+    end
+
+    # Free places of the simulation (belonging to the net).
+    # 
+    def tS_tt( ids=nil )
+      tS_transitions( ids ).sources
+    end
+
+    # Free places of the simulation (belonging to the net).
+    # 
+    def Ts_tt( ids=nil )
+      Ts_transitions( ids ).sources
+    end
+
+    # Free places of the simulation (belonging to the net).
+    # 
+    def TS_tt( ids=nil )
+      TS_transitions( ids ).sources
+    end
+
+    # Transitions' names. Arguments, if any, are treated as in +#tranistions+ method.
+    # 
+    def tn ids=nil
+      transitions( ids ).names
+    end
+
+    # Names of *ts* transitions. Arguments are handled as with +#ts_transitions+.
+    # 
+    def nts ids=nil
+      ts_transitions( ids ).names( true )
+    end
+
+    # Names of *tS* transitions. Arguments are handled as with +#tS_transitions+.
+    # 
+    def ntS ids=nil
+      tS_transitions( ids ).names( true )
+    end
+
+    # Names of *Ts* transitions. Arguments are handled as with +#tS_transitions+.
+    # 
+    def nTs ids=nil
+      Ts_transitions( ids ).names( true )
+    end
+
+    # Names of *TS* transitions. Arguments are handled as with +#TS_transitions+.
+    # 
+    def nTS ids=nil
+      TS_transitions( ids ).names( true )
+    end
+
+    # Names of *A* transitions. Arguments are handled as with +#A_transitions+.
+    # 
+    def nA ids=nil
+      A_transitions( ids ).names( true )
+    end
+
+    # Names of *S* transitions. Arguments are handled as with +#S_transitions+.
+    # 
+    def nS ids=nil
+      S_transitions( ids ).names( true )
+    end
+
+    # Names of *s* transitions. Arguments are handled as with +#s_transitions+.
+    # 
+    def ns ids=nil
+      s_transitions( ids ).names( true )
+    end
+
+    protected
+
+    # Transition instance identification.
+    # 
+    def transition( id )
+      begin
+        Transition().instance( id )
+      rescue NameError, TypeError
+        begin
+          tr = net.transition( id )
+          Transition().instances.find { |t_rep| t_rep.source == tr } || 
+            Transition().instance( tr.name )
+        rescue NameError, TypeError => msg
+          raise TypeError, "The argument #{id} does not identify a " +
+            "transition instance! (#{msg})"
+        end
+      end
+    end
+
+    # Without arguments, returns all the transitions. If arguments are given,
+    # they are converted to transitions before being returned.
+    # 
+    def transitions ids=nil
+      return @transitions if ids.nil?
+      Transitions().load( ids.map { |id| transition id } )
+    end
+
+    # Simulation's *ts* transtitions. If arguments are given, they must identify
+    # *ts* transitions, and are treated as in +#transitions+ method. Note that *A*
+    # transitions are not considered eligible *ts* tranisitions for the purposes
+    # of this method.
+    # 
+    def ts_transitions ids=nil
+      return transitions.ts if ids.nil?
+      transitions.ts.subset( ids )
+    end
+
+    # Simulation's *tS* transitions. If arguments are given, they must identify
+    # *tS* transitions, and are treated as in +#transitions+ method.
+    # 
+    def tS_transitions ids=nil
+      return transitions.tS if ids.nil?
+      transitions.tS.subset( ids )
+    end
+
+    # Simulation's *Ts* transitions. If arguments are given, they must identify
+    # *Ts* transitions, and are treated as in +#transitions+ method.
+    # 
+    def Ts_transitions ids=nil
+      return transitions.Ts if ids.nil?
+      transitions.Ts.subset( ids )
+    end
+
+    # Simulation's *TS* transitions. If arguments are given, they must identify
+    # *TS* transitions, and are treated as in +#transitions+ method.
+    # 
+    def TS_transitions ids=nil
+      return transitions.TS if ids.nil?
+      transitions.TS.subset( ids )
+    end
+
+    # Simulation's *A* transitions. If arguments are given, they must identify
+    # *A* transitions, and are treated as in +#transitions+ method.
+    # 
+    def A_transitions ids=nil
+      return transitions.A if ids.nil?
+      transitions.A.subset( ids )
+    end
+
+    # Simulation's *S* transitions. If arguments are given, they must identify
+    # *S* transitions, and are treated as in +#transitions+ method.
+    # 
+    def S_transitions ids=nil
+      return transitions.S if ids.nil?
+      transitions.S.subset( ids )
+    end
+
+    # Simulation's *s* transitions. If arguments are given, they must identify
+    # *s* transitions, and are treated as in +#transitions+ method.
+    # 
+    def s_transitions ids=nil
+      return transitions.s if ids.nil?
+      transitions.s.subset( ids )
+    end
+  end # Access
+end # class YPetri::Simulation::Transitions

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

@@ -0,0 +1,9 @@
+#encoding: utf-8
+
+# A mixin for collections of s transitions.
+# 
+class YPetri::Simulation::Transitions
+  module Type_s
+    include Type_a
+  end # module Type_s
+end # class YPetri::Simulation::Transitions

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

@@ -0,0 +1,22 @@
+#encoding: utf-8
+
+# A mixin for collections of t transitions.
+# 
+class YPetri::Simulation::Transitions
+  module Type_t
+    include Type_a
+
+    # State change if the timeless transitions fire once.
+    # 
+    def delta
+      ts.delta + tS.delta
+    end
+
+    # State change if the timeless transitions fire once.
+    # 
+    def Δ
+      tS.Δ + ts.Δ
+    end
+    alias delta_all delta
+  end # module Type_T
+end # class YPetri::Simulation::Transitions

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

@@ -0,0 +1,55 @@
+#encoding: utf-8
+
+# A mixin for collections of tS transitions.
+# 
+class YPetri::Simulation::Transitions
+  module Type_tS
+    include Type_t
+    include Type_S
+
+    # firing closure accessor.
+    # 
+    def firing_closure
+      @firing_closure ||= to_firing_closure
+    end
+
+    # tS transitions have firing closures.
+    # 
+    def firing_closures
+      map &:firing_closure
+    end
+    
+    # Firing vector (to be multiplied by the stoichiometry to get deltas)
+    # 
+    def firing_vector
+      firing_closure.call
+    end
+
+    # Firing vector for these tS transitions, returned as array.
+    # 
+    def firing
+      firing_closures.map &:call
+    end
+
+    # Delta contribution to free places.
+    # 
+    def delta
+      stoichiometry_matrix * firing_vector
+    end
+
+    # Delta contribution to all places
+    # 
+    def Δ
+      SM() * firing_vector
+    end
+    alias delta_all Δ
+
+    # Builds the firing vector closure, that outputs the firing vector based on
+    # the system state when called.
+    # 
+    def to_firing_closure
+      closures = firing_closures
+      -> { closures.map( &:call ).to_column_vector }
+    end
+  end # module Type_tS
+end # class YPetri::Simulation::Transitions

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

@@ -0,0 +1,58 @@
+#encoding: utf-8
+
+# A mixin for collections of ts transitions.
+# 
+class YPetri::Simulation::Transitions
+  module Type_ts
+    include Type_t
+    include Type_s
+
+    # Delta closure accessor.
+    # 
+    def delta_closure
+      @delta_closure ||= to_delta_closure
+    end
+
+    # ts transitions have action closures.
+    # 
+    def delta_closures
+      map &:delta_closure
+    end
+
+    # Delta contribution to free places.
+    # 
+    def delta
+      delta_closure.call
+    end
+
+    # Delta contribution to all places
+    # 
+    def Δ
+      f2a * delta
+    end
+    alias delta_all Δ
+
+    # Constructs a delta closure that outputs a delta vector corresponding to
+    # free places. The vector is the delta contribution of the transitions in
+    # this collection.
+    # 
+    def to_delta_closure
+      fp = free_places
+      closures = delta_closures
+      sMV = simulation.MarkingVector
+      code_sections = map.with_index do |t, i|
+        "a = closures[#{i}].call\n" +
+          t.increment_by_codomain_code( vector: "delta", source: "a" )
+      end
+      body = code_sections.join( "\n" )
+      λ = <<-LAMBDA
+        -> do
+        delta = sMV.zero( fp )
+        #{body}
+        return delta
+        end
+      LAMBDA
+      eval λ
+    end
+  end
+end # class YPetri::Simulation::Transitions

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

@@ -0,0 +1,98 @@
+#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 type selectors.
+# 
+class YPetri::Simulation::Transitions
+  module Types
+    # Subset of s type transitions, if any.
+    # 
+    def s
+      ( @Type_s ||= Class.new( self.class ).tap do |klass|
+          klass.class_exec { include Type_s }
+        end ).load subset( &:s? )
+    end
+    
+    # Subset of S type transitions, if any.
+    # 
+    def S
+      ( @Type_S ||= Class.new( self.class ).tap do |klass|
+          klass.class_exec { include Type_S }
+        end ).load subset( &:S? )
+    end
+    
+    # Subset of t type transitions, if any.
+    # 
+    def t
+      ( @Type_t ||= Class.new( self.class ).tap do |klass|
+          klass.class_exec { include Type_t }
+        end ).load subset( &:t? )
+    end
+    
+    # Subset of T type transitions, if any.
+    # 
+    def T
+      ( @Type_T ||= Class.new( self.class ).tap do |klass|
+          klass.class_exec { include Type_T }
+        end ).load subset( &:T? )
+    end
+    
+    # Subset of ts type transitions, if any.
+    # 
+    def ts
+      ( @Type_ts ||= Class.new( self.class ).tap do |klass|
+          klass.class_exec { include Type_ts }
+        end ).load subset( &:ts? )
+    end
+    
+    # Subset of tS type transitions, if any.
+    # 
+    def tS
+      ( @Type_tS ||= Class.new( self.class ).tap do |klass|
+          klass.class_exec { include Type_tS }
+        end ).load subset( &:tS? )
+    end
+    
+    # Subset of Ts type transitions, if any.
+    # 
+    def Ts
+      ( @Type_Ts ||= Class.new( self.class ).tap do |klass|
+          klass.class_exec { include Type_Ts }
+        end ).load subset( &:Ts? )
+    end
+    
+    # Subset of TS type transitions, if any.
+    # 
+    def TS
+      ( @Type_TS ||= Class.new( self.class ).tap do |klass|
+          klass.class_exec { include Type_TS }
+        end ).load subset( &:TS? )
+    end
+    
+    # Subset of A type transitions, if any.
+    # 
+    def A
+      ( @Type_A ||= Class.new( self.class ).tap do |klass|
+          klass.class_exec { include Type_A }
+        end ).load subset( &:A? )
+    end
+    
+    # Subset of a type transitions, if any.
+    # 
+    def a
+      ( @Type_a ||= Class.new( self.class ).tap do |klass|
+          klass.class_exec { include Type_a }
+        end ).load subset( &:a? )
+    end
+  end # Types
+end # class YPetri::Simulation::Transitions

data/lib/y_petri/simulation/transitions.rb

@@ -0,0 +1,21 @@
+#encoding: utf-8
+
+# Transition collection for YPetri::Simulation.
+#
+class YPetri::Simulation
+  class Transitions < Elements
+    require_relative 'transitions/types'
+    include Types
+
+    # Pushes a transition to the collection.
+    # 
+    def push transition
+      t = begin
+            net.transition( transition )
+          rescue NameError, TypeError
+            return super transition( transition )
+          end
+      super t.name ? Transition().new( t, name: t.name ) : Transition().new( t )
+    end
+  end # class Transitions
+end # class YPetri::Simulation::Transitions