y_petri 2.0.15 → 2.1.3

data/lib/y_petri/core.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+
+class YPetri::Core
+  DEFAULT_METHOD = :pseudo_euler
+
+  module Guarded
+    # Guarded simulation.
+    # 
+    def guarded?
+      true
+    end
+
+    # Guarded version of the method.
+    # 
+    def increment_marking_vector( delta )
+      try "to update marking" do
+        super( note( "Δ state if tS transitions fire once",
+                     is: Δ_if_tS_fire_once ) +
+               note( "Δ state if tsa transitions fire once",
+                     is: Δ_if_tsa_fire_once ) )
+      end
+    end
+
+    # Guarded version of the method.
+    # 
+    def A_all_fire!
+      try "to fire the assignment transitions" do
+        super
+      end
+    end
+  end
+
+  include YPetri::Simulation::Dependency
+
+  delegate :simulation, to: "self.class"
+  delegate :alert, to: :recorder
+
+  class << self
+    alias __new__ new
+
+    def new( method: nil, guarded: false, **nn )
+      # Alow for named arg. alias :simulation_method
+      sm = method || nn[:simulation_method] || DEFAULT_METHOD
+      using_simulation_method( sm, guarded: guarded ).__new__
+    end
+
+    def using_simulation_method symbol, guarded: false
+      simulation_method_module = const_get( symbol.to_s.camelize )
+      # TODO: "guarded" argument not handled yet
+      Class.new self do prepend( simulation_method_module ) end
+    end
+  end
+
+  # Simlation is not guarded by default.
+  # 
+  def guarded?
+    false
+  end
+
+  # Delta for free places.
+  # 
+  def delta_timeless
+    delta_ts + delta_tS
+  end
+  alias delta_t delta_timeless
+
+  # Delta contribution by tS transitions.
+  # 
+  def delta_tS
+    simulation.tS_stoichiometry_matrix * firing_vector_tS
+  end
+
+  # Delta contribution by ts transitions.
+  # 
+  def delta_ts
+    simulation.ts_delta_closure.call
+  end
+
+  # Firing vector of tS transitions.
+  # 
+  def firing_vector_tS
+    simulation.tS_firing_closure.call
+  end
+
+  # Increments the marking vector by a given delta.
+  # 
+  def increment_marking_vector( delta )
+    print '.'
+    simulation.increment_marking_vector_closure.( delta )
+  end
+
+  # Fires assignment transitions.
+  # 
+  def assignment_transitions_all_fire!
+    simulation.A_assignment_closure.call
+  end
+end # class YPetri::Core
+
+require_relative 'core/timed'
+require_relative 'core/timeless'

data/lib/y_petri/dsl.rb

@@ -0,0 +1,66 @@
+module YPetri
+  # YPetri DSL.
+  # 
+  module DSL
+    def y_petri_agent
+      @y_petri_agent ||= Agent.new
+        .tap { puts "Defining agent for #{self}" if YPetri::DEBUG }
+    end
+  end
+
+  delegate :world, to: :y_petri_agent
+
+  # Petri net aspect.
+  delegate( :Place,
+            :Transition, :T, :A,
+            :Net,
+            :place, :transition, :pl, :tr,
+            :places, :transitions, :nets,
+            :pn, :tn, :nn,
+            :net_point,
+            :net_selection,
+            :net, :nnet,
+            :net_point_reset,
+            :net_point=,
+            to: :y_petri_agent )
+
+  # Simulation aspect.
+  delegate( :simulation_point, :ssc_point, :cc_point, :imc_point,
+            :simulation_selection, :ssc_selection,
+            :cc_selection, :imc_selection,
+            :simulations,
+            :clamp_collections,
+            :initial_marking_collections,
+            :simulation_settings_collections,
+            :clamp_collection_names, :ncc,
+            :initial_marking_collection_names, :nimc,
+            :simulation_settings_collection_names, :nssc,
+            :set_clamp_collection, :set_cc,
+            :set_initial_marking_collection, :set_imc,
+            :set_simulation_settings_collection, :set_ssc,
+            :new_simulation,
+            :clamp_cc, :initial_marking_cc, :simulation_settings_cc,
+            :simulation_point_position,
+            :simulation,
+            :clamp_collection, :cc,
+            :initial_marking_collection, :imc,
+            :simulation_settings_collection, :ssc,
+            :clamp,
+            :initial_marking,
+            :set_step, :set_step_size,
+            :set_time, :set_target_time,
+            :set_sampling,
+            :set_simulation_method,
+            :new_timed_simulation,
+            :run!,
+            :print_recording,
+            :plot,
+            :plot_selected,
+#            :plot_state,
+            :plot_flux,
+            to: :y_petri_agent )
+
+  def plot_state **nn
+    simulation.recording.marking.plot **nn
+  end
+end

data/lib/y_petri/fixed_assets.rb

@@ -0,0 +1,7 @@
+#encoding: utf-8
+
+# Public command interface of YPetri.
+# 
+module YPetri
+  GuardError = Class.new TypeError
+end # module YPetri

data/lib/y_petri/net/element_access.rb

@@ -0,0 +1,239 @@
+# Selections of various kinds of places / transitions (place names / transition
+# names) in a Petri net.
+# 
+module YPetri::Net::ElementAccess
+  # Does the net include a place?
+  # 
+  def includes_place? id
+    begin
+      place( id ) and true
+    rescue NameError, TypeError; false end
+  end
+  alias include_place? includes_place?
+
+  # Does the net include a transition?
+  # 
+  def includes_transition? id
+    begin; transition( id ) and true; rescue NameError, TypeError; false end
+  end
+  alias include_transition? includes_transition?
+
+  # Inquirer whether the net includes an element.
+  # 
+  def include? id
+    include_place?( id ) || include_transition?( id )
+  end
+  alias includes? include?
+
+  # Returns the net's place identified by the argument.
+  # 
+  def place id
+    ( super rescue Place().instance( id ) ).tap do |p|
+      fail TypeError, "No place #{id} in the net!" unless places.include? p
+    end
+  end
+  
+  # Returns the net's transition identified by the argument.
+  # 
+  def transition id
+    ( super rescue Transition().instance( id ) ).tap do |t|
+      transitions.include? t or fail TypeError, "No transition #{id} in the net!"
+    end
+  end
+
+  # Returns the net's element identified by the argument
+  # 
+  def element id
+    begin; place( id ); rescue NameError, TypeError
+      begin; transition( id ); rescue NameError, TypeError
+        raise TypeError, "The net does not include place/transition #{id}!"
+      end
+    end
+  end
+
+  # Returns the net's elements identified by the argument's elements.
+  # 
+  def elements ids=nil
+    return @places + @transitions if ids.nil?
+    ids.map { |id| element id }
+  end
+
+  # Returns the names of the net's elements identified by the array.
+  # 
+  def en ids=nil
+    elements( ids ).names
+  end
+
+  # Returns the net's places identified by the argument's elements.
+  # 
+  def places ids=nil
+    return @places.dup if ids.nil?
+    ids.map { |id| place id }
+  end
+  alias pp places
+
+  # Returns the net's transitions identified by the argument's elements.
+  # 
+  def transitions ids=nil
+    return @transitions.dup if ids.nil?
+    ids.map { |id| transition id }
+  end
+  alias tt transitions
+
+  # Names of places in the net.
+  # 
+  def pn ids=nil
+    places( ids ).names
+  end
+
+  # Names of transitions in the net.
+  # 
+  def tn ids=nil
+    transitions( ids ).names
+  end
+
+  # *ts* transitions.
+  # 
+  def ts_transitions ids=nil
+    return transitions.select &:ts? if ids.nil?
+    transitions( ids ).aT_all "transition identifiers", "be ts", &:ts?
+  end
+  alias ts_tt ts_transitions
+
+  # Names of *ts* transitions.
+  # 
+  def nts ids=nil
+    ts_transitions( ids ).names
+  end
+
+  # *tS* transitions.
+  # 
+  def tS_transitions ids=nil
+    return transitions.select &:tS? if ids.nil?
+    transitions( ids ).aT_all "transition identifiers", "be tS", &:tS?
+  end
+  alias tS_tt tS_transitions
+
+  # Names of *tS* transitions.
+  # 
+  def ntS ids=nil
+    tS_transitions( ids ).names
+  end
+
+  # *Ts* transitions.
+  # 
+  def Ts_transitions ids=nil
+    return transitions.select &:Ts? if ids.nil?
+    transitions( ids ).aT_all "transition identifiers", "be Ts", &:Ts?
+  end
+  alias Ts_tt Ts_transitions
+
+  # Names of *Ts* transitions.
+  # 
+  def nTs ids=nil
+    Ts_transitions( ids ).names
+  end
+
+  # *TS* transitions.
+  # 
+  def TS_transitions ids=nil
+    return transitions.select &:TS? if ids.nil?
+    transitions( ids ).aT_all "transition identifiers", "be TS", &:TS?
+  end
+  alias TS_tt TS_transitions
+
+  # Names of *TS* transitions.
+  # 
+  def nTS ids=nil
+    TS_transitions( ids ).names
+  end
+
+  # *A* transitions.
+  # 
+  def A_transitions ids=nil
+    return transitions.select &:A? if ids.nil?
+    transitions( ids ).aT_all "transition identifiers", "be A", &:A?
+  end
+  alias A_tt A_transitions
+
+  # Names of *A* transitions.
+  # 
+  def nA ids=nil
+    A_transitions( ids ).names
+  end
+
+  # *a* transitions.
+  # 
+  def a_transitions ids=nil
+    return transitions.select &:a? if ids.nil?
+    transitions( ids ).aT_all "transition identifiers",
+                              "be a (non-assignment)", &:a?
+  end
+  alias a_tt a_transitions
+
+  # Names of *a* transitions.
+  # 
+  def na ids=nil
+    A_transitions( ids ).names
+  end
+
+  # *S* transitions.
+  # 
+  def S_transitions ids=nil
+    return transitions.select &:S? if ids.nil?
+    transitions( ids ).aT_all "transition identifiers",
+                              "be S (stoichiometric)", &:S?
+  end
+  alias S_tt S_transitions
+
+  # Names of *S* transitions.
+  # 
+  def nS ids=nil
+    S_transitions( ids ).names
+  end
+
+  # *s* transitions.
+  # 
+  def s_transitions ids=nil
+    return transitions.select &:s? if ids.nil?
+    transitions( ids ).aT_all "transition identifiers",
+                              "be s (non-stoichiometric)", &:s?
+  end
+  alias s_tt s_transitions
+
+  # Names of *s* transitions.
+  # 
+  def ns ids=nil
+    s_transitions( ids ).names
+  end
+
+  # *T* transitions.
+  #
+  def T_transitions ids=nil
+    return transitions.select &:T? if ids.nil?
+    transitions( ids ).aT_all "transition identifiers",
+                              "be T (timed)", &:T?
+  end
+  alias T_tt T_transitions
+
+  # Names of *T* transitions.
+  # 
+  def nT ids=nil
+    T_transitions( ids ).names
+  end
+
+  # *t* transitions.
+  # 
+  def t_transitions ids=nil
+    return transitions.select &:t? if ids.nil?
+    transitions( ids ).aT_all "transition identifiers",
+                              "be t (timeless)", &:t?
+  end
+  alias t_tt t_transitions
+
+  # Names of *t* transitions.
+  # 
+  def nt ids=nil
+    t_transitions( ids ).names
+  end  
+end # class YPetri::Net::ElementAccess

data/lib/y_petri/net/state/feature/delta.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+
+class YPetri::Net::State
+  class Feature
+    # Change of a Petri net place caused by a certain set of transitions.
+    # 
+    class Delta < Feature
+      attr_reader :place, :transitions, :step
+
+      class << self
+        def parametrize *args
+          Class.instance_method( :parametrize ).bind( self ).( *args ).tap do |ç|
+            # First, prepare the hash of instances.
+            hsh = Hash.new do |ꜧ, id|
+              puts "Delta received:"
+              p id
+              puts "of class #{id.class}, with ancestors:"
+              p id.class.ancestors
+              if id.is_a? Delta then
+                ꜧ[ [ id.place, transitions: id.transitions.sort( &:object_id ) ] ]
+              else
+                puts "here"
+                p id
+                puts "id size is #{id.size}"
+                p = id.fetch( 0 )
+                tt = id
+                  .fetch( 1 )
+                  .fetch( :transitions )
+                if p.is_a? ç.net.Place and tt.all? { |t| t.is_a? ç.net.Transition }
+                  if tt == tt.sort then
+                    ꜧ[ id ] = ç.__new__( *id )
+                  else
+                    ꜧ[ [ p, transitions: tt.sort ] ]
+                  end
+                else
+                  ꜧ[ [ ç.net.place( p ), transitions: ç.net.transitions( tt ) ] ]
+                end
+              end
+            end
+            # And then, assign it to the :@instances variable.
+            ç.instance_variable_set :@instances, hsh
+          end
+        end
+
+        attr_reader :instances
+
+        alias __new__ new
+
+        def new *args
+          return instances[ *args ] if args.size == 1
+          instances[ args ]
+        end
+
+        def of *args
+          new *args
+        end
+      end
+
+      def initialize place, transitions: net.tt
+        @place = net.place( place )
+        @transitions = net.transitions( transitions )
+      end
+
+      def extract_from arg, **nn
+        # **nn is here because of timed / timeless possibility, where
+        # **nn would contain :step named argument.
+        case arg
+        when YPetri::Simulation then
+          _T = arg.send( :T_transitions, transitions )
+          _t = arg.send( :t_transitions, transitions )
+          if _T.empty? then _t.delta.fetch( place ) else # time step is required
+            _t.delta.fetch( place ) + _T.delta( nn[:step] ).fetch( place )
+          end
+        else
+          fail TypeError, "Argument type not supported!"
+        end
+      end
+
+      def to_s
+        place.name
+      end
+
+      def label
+        "∂:#{place.name}:#{transitions.size}tt"
+      end
+    end # class Delta
+  end # class Feature
+end # YPetri::Net::State

data/lib/y_petri/net/state/feature/firing.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+class YPetri::Net::State
+  class Feature
+    # Firing of a Petri net tS transition.
+    # 
+    class Firing < Feature
+      attr_reader :transition
+
+      class << self
+        def parametrize *args
+          Class.instance_method( :parametrize ).bind( self ).( *args ).tap do |ç|
+            ç.instance_variable_set( :@instances,
+                                     Hash.new do |hsh, id|
+                                       case id
+                                       when Firing then
+                                         hsh[ id.transition ]
+                                       when ç.net.Transition then
+                                         hsh[ id ] = ç.__new__( id )
+                                       else
+                                         hsh[ ç.net.transition( id ) ]
+                                       end
+                                     end )
+          end
+        end
+
+        attr_reader :instances
+
+        alias __new__ new
+
+        def new id
+          instances[ id ]
+        end
+
+        def of id
+          new id
+        end
+      end
+
+      def initialize transition
+        @transition = net.transition( transition )
+      end
+
+      def extract_from arg, **nn
+        case arg
+        when YPetri::Simulation then
+          arg.send( :tS_transitions, [ transition ] ).firing.first
+        else
+          fail TypeError, "Argument type not supported!"
+        end
+      end
+
+      def label
+        "f:#{transition.name}"
+      end
+    end # class Firing
+  end # class Feature
+end # YPetri::Net::State

data/lib/y_petri/net/state/feature/flux.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+class YPetri::Net::State
+  class Feature
+    # Flux of a Petri net TS transition.
+    # 
+    class Flux < Feature
+      attr_reader :transition
+
+      class << self
+        def parametrize *args
+          Class.instance_method( :parametrize ).bind( self ).( *args ).tap do |ç|
+            ç.instance_variable_set( :@instances,
+                                     Hash.new do |hsh, id|
+                                       case id
+                                       when Firing then
+                                         hsh[ id.transition ]
+                                       when ç.net.Transition then
+                                         hsh[ id ] = ç.__new__( id )
+                                       else
+                                         hsh[ ç.net.transition( id ) ]
+                                       end
+                                     end )
+          end
+        end
+
+        attr_reader :instances
+
+        alias __new__ new
+
+        def new id
+          instances[ id ]
+        end
+
+        def of transition_id
+          new transition_id
+        end
+      end
+
+      def initialize id
+        @transition = net.transition( id.is_a?( Flux ) ? id.transition : id )
+      end
+
+      def extract_from arg, **nn
+        case arg
+        when YPetri::Simulation then
+          arg.send( :TS_transitions, [ transition ] ).flux.first
+        else
+          fail TypeError, "Argument type not supported!"
+        end
+      end
+
+      def label
+        "Φ:#{transition.name}"
+      end
+    end # class Flux
+  end # class Feature
+end # YPetri::Net::State

data/lib/y_petri/net/state/feature/gradient.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+
+class YPetri::Net::State
+  class Feature
+    # Gradient of a Petri net place caused by a certain set of T transitions.
+    # 
+    class Gradient < Feature
+      attr_reader :place, :transitions
+
+      class << self
+        def parametrize *args
+          Class.instance_method( :parametrize ).bind( self ).( *args ).tap do |ç|
+            # First, prepare the hash of instances.
+            hsh = Hash.new do |ꜧ, id|
+              if id.is_a? Gradient then
+                ꜧ[ [ id.place, transitions: id.transitions.sort( &:object_id ) ] ]
+              else
+                p = id.fetch( 0 )
+                tt = id
+                  .fetch( 1 )
+                  .fetch( :transitions )
+                if p.is_a? ç.net.Place and tt.all? { |t| t.is_a? ç.net.Transition }
+                  if tt == tt.sort then
+                    ꜧ[ id ] = ç.__new__( *id )
+                  else
+                    ꜧ[ [ p, transitions: tt.sort ] ]
+                  end
+                else
+                  ꜧ[ [ ç.net.place( p ), transitions: ç.net.transitions( tt ) ] ]
+                end
+              end
+            end
+            # And then, assign it to the :@instances variable.
+            ç.instance_variable_set :@instances, hsh
+          end
+        end
+
+        attr_reader :instances
+
+        alias __new__ new
+
+        def new *args
+          return instances[ *args ] if args.size == 1
+          instances[ args ]
+        end
+
+        def of *args
+          new *args
+        end
+      end
+
+      def initialize *id
+        @place = net.place id.fetch( 0 )
+        @transitions = net.transitions id.fetch( 1 ).fetch( :transitions )
+      end
+
+      def extract_from arg, **nn
+        case arg
+        when YPetri::Simulation then
+          arg.send( :T_transitions, transitions ).gradient.fetch( place )
+        else
+          fail TypeError, "Argument type not supported!"
+        end
+      end
+
+      def to_s
+        place.name
+      end
+
+      def label
+        "∂:#{place.name}:#{transitions.size}tt"
+      end
+    end # class Gradient
+  end # class Feature
+end # YPetri::Net::State