y_petri 2.3.11 → 2.3.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 213efc795950a5d200a6b5c10fe3150dddf4940b
-  data.tar.gz: 6c1a54e4526c7f19ea63dc7faad780526e2d3ee2
+  metadata.gz: 3fe2aaae8033f7806b851cd4293f555d15beb5a5
+  data.tar.gz: 79271fa571273448d6716b547785f66805b5d5b4
 SHA512:
-  metadata.gz: 60800f142748c833d2298583393f3790532d56bf294779d02a6e6b6991409bdc12b584bf64ec286868012d3b4d25e0a18cc8a5ac170359ab4c00ca7c703fdf52
-  data.tar.gz: aacfcbc2bbba5c262c5e2cab747a4fe093d047b02a65781709eec758a30b5bc9222dcd0a6874afdf1041d1a8d3f9d9e143fe0bd80f26361df6f5cd4b64e9182e
+  metadata.gz: 14a6aba15f89a662ee2e13e16dc09695c1d00ccbe60ce7f969b9ae2a348f9bc8c98f51a2090643671b568d06f36419d162dda8ef5005fd34f014ec28aa75a855
+  data.tar.gz: 66681f89b12fc840eabc2d225af8e137492870c61c8d844b8fcb73cd78ef712bfe46c497882be534a98e5287bb76e7aa97a726f032bd16346cb79a735d4069e9

data/lib/y_petri/core/timed/{pseudo_euler.rb → basic.rb}

@@ -1,9 +1,9 @@
 # encoding: utf-8
 
-# Adaptation of Euler method for the systems possibly with timeless transitions
-# and assignment transitions.
+# Basic Petri net execution method for timed and hybrid nets. Works also for
+# timeless nets, but for those, Core::Timeless::Basic is slightly more efficient.
 # 
-module YPetri::Core::Timed::PseudoEuler
+module YPetri::Core::Timed::Basic
   # Computes Δ for the period of Δt. Its result is a sum of the contribution of
   # timed transitions over the period Δt and the contribution of timeless
   # transitions as if each fired once.
@@ -23,4 +23,4 @@ module YPetri::Core::Timed::PseudoEuler
     simulation.increment_time! Δt
     alert! # alerts the sampler that the system has changed
   end
-end # YPetri::Core::Timed::PseudoEuler
+end # YPetri::Core::Timed::Basic

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

@@ -4,9 +4,7 @@
 # 
 module YPetri::Core::Timed::RungeKutta
   def delta Δt
-    fail NotImplementedError, "RungeKutta not implemented yet!"
-
-    # f = simulation.method :gradient, parameter: :state
+    # 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|

data/lib/y_petri/core/timed/{quasi_euler.rb → ticked.rb}

@@ -4,7 +4,7 @@
 # and assignment transitions. Unlike +pseudo_euler+, which fires every step,
 # +quasi_euler+ fires every time tick. Not implemented yet.
 # 
-module YPetri::Core::Timed::QuasiEuler
+module YPetri::Core::Timed::Ticked
   # Computes Δ for the period of Δt. Not mplemented yet.
   # 
   def delta Δt
@@ -19,4 +19,4 @@ module YPetri::Core::Timed::QuasiEuler
     # Now one would have to compare whichever comes first, time tick or the
     # end of Δt, and then again and again, until Δt is fired...
   end
-end # YPetri::Core::Timed::QuasiEuler
+end # YPetri::Core::Timed::Ticked

data/lib/y_petri/core/timed.rb

@@ -1,10 +1,34 @@
 # encoding: utf-8
 
-# Timed simulation core.
+# Timed simulation core. Knows several simulation methods applicable to
+# timed nets.
 # 
-module YPetri::Core::Timed
-  require_relative 'timed/methods'
-  ★ Methods
+class YPetri::Core::Timed
+  ★ YPetri::Core
+  
+  require_relative 'timed/basic'
+  require_relative 'timed/ticked'       # 
+  require_relative 'timed/euler'
+  require_relative 'timed/runge_kutta'
+  require_relative 'timed/gillespie'
+
+  METHODS = {
+    basic: Basic,   # simple PN execution, timeless tt fire after each step
+    ticked: Ticked, # like basic, but timeless tt fire at every time tick
+    euler: Euler,               # for timed nets only
+    runge_kutta: RungeKutta,    # for timed nets only
+    gillespie: Gillespie        # for timed nets only
+  }
+
+  def initialize **named_args
+    super
+    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
+  end
 
   # Makes a single step by Δt.
   # 
@@ -25,6 +49,8 @@ module YPetri::Core::Timed
   # 
   def gradient_Ts
     simulation.Ts_gradient_closure.call
+    # this could be
+    # @Ts_gradient_closure.call
   end
 
   # Gradient contribution by TS transitions.
@@ -51,11 +77,9 @@ module YPetri::Core::Timed
   alias propensity_vector_TS flux_vector_TS
 end # module YPetri::Core::Timed
 
-# In general, it is not required that all net nodes are simulated with the
-# same method. Practically, ODE systems have many good simulation methods
-# available.
+# Textbook simulation methods ODE systems have many good simulation methods available.
 #
-# (1) ᴍ(t) = ϝ f(ᴍ, t).dt, where f(ᴍ, t) is a known function.
+# (1) mv' = ϝ f(mv, t).dt, where f(m, t) is a known function.
 #
 # Many of these methods depend on the Jacobian, but that may not be available
 # for some places. Therefore, the places, whose marking defines the system
@@ -66,3 +90,5 @@ end # module YPetri::Core::Timed
 # If we apply the definition of "causal orientation" on A and E places, then it
 # can be said, that only the transitions causally oriented towards "A" places
 # are allowed for compliance with the equation (1).
+
+# In general, it is not required that all net nodes are simulated with the same method.

data/lib/y_petri/core/timeless/basic.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+# The basic simulation method in YPetri is simple Petri net (PN) execution. While
+# in principle applicable to any PN type, it can be made slightly more efficient
+# if it is known in advance that no no timed transitions will be in the net.
+#
+module YPetri::Core::Timeless::Basic
+  # Peforms a single step of the basic method.
+  # 
+  def step!
+    # Compute the sum of the contribution of ts and tS transitions, and
+    # increment the free marking vector by it.
+    increment_free_vector by: delta_ts + delta_tS
+    # Fire all the assignment transitions in their order.
+    fire_all_assignment_transitions!
+    # before: assignment_transitions_all_fire!
+    # Alert the recorder(s) that the system has changed.
+    alert!
+  end
+end # module YPetri::Core::Timeless::Basic

data/lib/y_petri/core/timeless.rb

@@ -1,15 +1,27 @@
 # encoding: utf-8
 
-# Timeless simulator mixin.
+# Timeless simulator core. Knows thus far only one, but potentially several
+# methods applicable to timeless systems simulations.
 # 
-module YPetri::Core::Timeless
-  require_relative 'timeless/methods'
-  ★ Methods
+class YPetri::Core::Timeless
+  ★ YPetri::Core
+  
+  require_relative 'timeless/basic'
+  
+  METHODS = { basic: Basic } # basic PN execution
+  # Note: the reason why Timeless core has distinct basic method is because
+  # without having to consider timed transitions, it can be made simpler.
 
-  # Makes a single step.
+  def initialize **named_args
+    super
+    extend METHODS.fetch simulation_method
+  end
+  
+  # Computes the system state delta.
   # 
   def delta
-    delta_timeless
+    delta_timeless # this method was taken from core.rb
+    # delta_ts + delta_tS # this is the contents of delta_timeless method
   end
 
   # Computes the system state delta.

data/lib/y_petri/core.rb

@@ -1,83 +1,62 @@
 # encoding: utf-8
 
-# This class represents a simulator.
+# This module represents a simulation core (execution machine), which can be
+# either timed (class Core::Timed) or timeless (class Core::Timeless).
 # 
-class YPetri::Core
-  # TODO: currently, Core and Simulation classes are tightly coupled.
-  # each simulation has just one core, and that core looks directly
-  # into the simulation's state. What needs to be done is a simulation
-  # that at least hints the process of core recruitment for the requested
-  # operation (be it step, step backwards, run forward aso.) and then
-  # imprints the core with its current marking vector, tells the core
-  # what to do, and then reads the result and updates its marking vector
-  # accordingly. There are multiple possibilities, such as constructing
-  # a new core for each operation, or keeping the same core for all the
-  # operations using a given method. A simulation method (like euler,
-  # gillespie, or runge-kutta) should be associated not so much with
-  # the simulation object, as it should be associated with the core
-  # object. A core object should be more or less one-trick pony. While
-  # later, it is possible for a simulation to have broader simulation
-  # strategy, or "method" in the broader sense. But simulation should
-  # also avoid doing too much, because above it, there is Agent class,
-  # and this class can be taught to do the more complicated things
-  # such as parameter optimization or computation of control coefficients
-  # and such. It is also possible to construct more specialized agent-like
-  # classes for these more specialized tasks, since the main purpose
-  # of Agent class, as I saw it, was to represent the user (represent
-  # what the user means), to provide the user interface.
-  
+module YPetri::Core
+  ★ YPetri::Simulation::Dependency # dependency stays for now
+
   require_relative 'core/timed'
   require_relative 'core/timeless'
-  require_relative 'core/guarded'
 
-  ★ YPetri::Simulation::Dependency
+  DEFAULT_METHOD = :basic
 
-  DEFAULT_METHOD = :pseudo_euler
+  # 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.)
+  # 
+  attr_reader :simulation         # just a remark:
+  attr_reader :simulation_method  # "reader" is "selector" in Landin's language
 
-  class << self
-    # Timed subclass of self.
-    # 
-    def timed
-      Class.new self do
-        include Timed
-        def timed?; true end
-        def timeless?; false end
-      end
-    end
-
-    # Timeless subclass of self.
-    # 
-    def timeless
-      Class.new self do
-        include Timeless
-        def timed?; false end
-        def timeless?; true end
-      end
-    end
-
-    # Vanilla simulator is not guarded.
+  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.
     # 
-    def guarded?; false end
+    @delta_closure_for_ts_transitions = simulation.ts_delta_closure
 
-    # Guarded subclass of self (not working yet).
+    # 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.
     # 
-    def guarded
-      Class.new self do
-        include Guarded
-        def guarded?; true end
-      end
-    end
-  end
+    @firing_closure_for_tS_transitions = simulation.tS_firing_closure
 
-  attr_reader :simulation_method
+    # 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
 
-  def initialize method: nil, guarded: false, **named_args
-    @simulation_method = method || DEFAULT_METHOD
-    method_init # defined in Timed::Methods and Timeless::Methods
+    # 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.
   end
 
-  delegate :simulation,
-           :timed?,
+  # 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"
@@ -102,24 +81,71 @@ class YPetri::Core
   # 
   def delta_ts
     simulation.ts_delta_closure.call
+    # @delta_closure_for_ts_transitions.call
   end
 
   # Firing vector of tS transitions.
   # 
   def firing_vector_tS
     simulation.tS_firing_closure.call
+    # @firing_closure_for_tS_transitions.call
   end
 
   # Increments the marking vector by a given delta.
   # 
   def increment_marking_vector( delta )
     print '.'
+    # TODO: From now on, this won't touch the simulation's property
+    # at all. It will be left to the simulation to ask for the results,
+    # or to rig the core to message back when done.
     simulation.increment_marking_vector_closure.( delta )
   end
 
-  # Fires assignment transitions.
+  # Fires all the assignment transitions.
   # 
-  def assignment_transitions_all_fire!
+  def fire_all_assignment_transitions!
     simulation.A_direct_assignment_closure.call
+    # @assignment_closure_for_A_transitions.call
   end
-end # class YPetri::Core
+  alias assignment_transitions_all_fire! fire_all_assignment_transitions!
+end # module YPetri::Core
+
+# TODO: Decouple Core and Simulation classes. It still looks like one
+# simulation will use only one core (or one for each type of simulation
+# trick), but I don't want the core to be parametrized by a Simulation
+# instance. There should be at least a hint of core recruitment, sending
+# the state to the core, asking the core to perform its trick on it, and
+# asking back the results (or rigging the core to send them back as soon
+# as done). A core should be more or less a one-trick pony. But simulation
+# should also avoid doing too much, because above it, other classes (Agent
+# and co.) may exist, doing things like optimization, parameter inferences
+# aso.
+
+# TODO: Regarding guarded cores, many kinds of PNs prohibit places from
+# acquiring negative marking, or impose other restrictions. If the system
+# state somehow makes it out of this safe envelope, the transitions may
+# start behaving unpredictably. So there is a question of who is responsible
+# for keeping the system sane (in the safe state envelope). The simple thing
+# is for the core not to test anything and leave it up to the user not to
+# define systems that are not sane. Simple is good, but there must be agreement,
+# a requirement that the system specification behaves. If there is no such
+# agreement, the core has no excuse from the need to guard against transitions
+# trying to fire when they should properly be disabled (at least not if the
+# core knows that the PN in question is classical). I did not decide what exactly
+# should happen if the sanity is broken (raise an error? warn and try minor
+# repair measures yourself?), but something should.
+#
+# Another example, in chemical systems, negative markings (concentrations)
+# also ordinarily make no sense. But insensitive combination of functions
+# and simulation method may lead to unsafe state with relatively late detection
+# of error, leaving the modeller wondering when exactly the system state went
+# haywire. Again, I'm not sure how exactly should the guarded core react to
+# the treat of insane situation, but it somehow should.
+#
+# I feel it is necessary for the core to have awareness of the quality of
+# the momentary system's state (at least to be able to tell whether it's
+# meaningful at all), because later I want to let the core choose between
+# 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/fixed_assets.rb

@@ -9,7 +9,7 @@ module YPetri
   Transition = Class.new
   Net = Class.new Module
   Simulation = Class.new
-  Core = Class.new
+  Core = Module.new
   World = Class.new
   Agent = Class.new
 end # module YPetri

data/lib/y_petri/simulation/timed.rb

@@ -254,14 +254,15 @@ module YPetri::Simulation::Timed
       @time_unit = anything.class.one
       @initial_time, @target_time = time_unit * 0, time_unit * Float::INFINITY
     end
-    init_core_and_recorder_subclasses
+    # Set up a parametrized subclas of the sampler for timed simulation.
+    param_class( { Recorder: Recorder }, with: { simulation: self } )
     reset_time!
     @step = settings[:step] || time_unit
     @default_sampling = settings[:sampling] || step
     @core = if @guarded then
-              Core().guarded.new( method: method )
+              YPetri::Core::Timed.new( simulation: self, method: method, guarded: true )
             else
-              Core().new( method: method )
+              YPetri::Core::Timed.new( simulation: self, method: method, guarded: false )
             end
     @recorder = if features_to_record then
                   # we'll have to figure out features
@@ -277,13 +278,4 @@ module YPetri::Simulation::Timed
                   Recorder().new( sampling: settings[:sampling] )
                 end
   end
-
-  # Sets up subclasses of +Core+ (the simulator) and +Recorder+ (the sampler)
-  # for timed simulations.
-  # 
-  def init_core_and_recorder_subclasses
-    param_class( { Core: YPetri::Core.timed,
-                   Recorder: Recorder },
-                 with: { simulation: self } )
-  end
 end # module YPetri::Simulation::Timed

data/lib/y_petri/simulation/timeless.rb

@@ -2,36 +2,38 @@
 
 # A mixin for timeless simulations.
 # 
-class YPetri::Simulation
-  module Timeless
-    require_relative 'timeless/recorder'
+module YPetri::Simulation::Timeless
+  require_relative 'timeless/recorder'
 
-    # False for timeless simulations.
-    # 
-    def timed?
-      false
-    end
+  # False for timeless simulations.
+  # 
+  def timed?
+    false
+  end
 
-    # Changing the simulation method on the fly not supported.
-    # 
-    def set_simulation_method
-      fail NoMethodError, "Changing simulation method on the fly not supported!"
-    end
+  # Changing the simulation method on the fly not supported.
+  # 
+  def set_simulation_method
+    fail NoMethodError, "Changing simulation method on the fly not supported!"
+  end
 
-    private
+  private
 
-    # Initialization subroutine for timeless simulations. Sets up the
-    # parametrized subclasses +@Core+ (the simulator) and +@Recorder+,
-    # and initializes the +@recorder+ attribute.
-    # 
-    def init **settings
-      method = settings[:method] # the simulation method
-      features_to_record = settings[:record]
-      init_core_and_recorder_subclasses
+  # Initialization subroutine for timeless simulations. Sets up the
+  # parametrized subclasses +@Core+ (the simulator) and +@Recorder+,
+  # and initializes the +@recorder+ attribute.
+  # 
+  def init **settings
+    method = settings[:method] # the simulation method
+    features_to_record = settings[:record]
+    # Sets up a parametrized subclass of the sampler for timeless simulation.
+      param_class( { Recorder: Recorder }, with: { simulation: self } )
       @core = if @guarded then
-                Core().guarded.new( method: method )
+                YPetri::Core::Timeless
+                  .new( simulation: self, method: method, guarded: true )
               else
-                Core().new( method: method )
+                YPetri::Core::Timeless
+                  .new( simulation: self, method: method, guarded: false )
               end
       @recorder = if features_to_record then 
                     # we'll have to figure out features
@@ -47,14 +49,4 @@ class YPetri::Simulation
                     Recorder().new # init the recorder
                   end
     end
-
-    # Sets up subclasses of +Core+ (the simulator) and +Recorder+ (the sampler)
-    # for timeless simulations.
-    # 
-    def init_core_and_recorder_subclasses
-      param_class( { Core: YPetri::Core.timeless,
-                     Recorder: Recorder },
-                   with: { simulation: self } )
-    end
-  end # module Timeless
-end # module YPetri::Simulation
+end # module YPetri::Simulation::Timeless

data/lib/y_petri/simulation.rb

@@ -42,7 +42,7 @@ class YPetri::Simulation
   ★ MarkingClamps::Access
   ★ MarkingVector::Access
 
-  DEFAULT_SETTINGS = -> do { method: :pseudo_euler, guarded: false } end
+  DEFAULT_SETTINGS = -> do { method: :basic, guarded: false } end
 
   class << self
     alias __new__ new

data/lib/y_petri/version.rb

@@ -1,4 +1,4 @@
 module YPetri
-  VERSION = "2.3.11"
+  VERSION = "2.3.12"
   DEBUG = false
 end

data/test/simulation_test.rb

@@ -123,7 +123,7 @@ require_relative '../lib/y_petri'     # tested component itself
 #             @sim.m.must_equal [1, 2]
 #             @sim.p_m.must_equal( { A: 1, B: 2 } )
 #             @sim.recording.must_equal( { 0 => [1, 2]} )
-#             @sim.simulation_method.must_equal :pseudo_euler
+#             @sim.simulation_method.must_equal :basic
 #             @sim.core.must_be_kind_of YPetri::Core
 #             @sim.ts_tt.first.domain.must_equal []
 #             @sim.send( :ts_transitions ).first.domain_access_code.must_equal ''
@@ -195,7 +195,7 @@ require_relative '../lib/y_petri'     # tested component itself
 
 #           it "should behave" do
 #             @sim.timed?.must_equal true
-#             @sim.simulation_method.must_equal :pseudo_euler
+#             @sim.simulation_method.must_equal :basic
 #             @sim.Ts_tt.size.must_equal 1
 #             @sim.send( :transitions ).Ts.first.gradient_closure.call.must_equal [1]
 #             @sim.Ts_tt.first.codomain.names.must_equal [:A]
@@ -212,7 +212,7 @@ require_relative '../lib/y_petri'     # tested component itself
 
 #           it "should behave" do
 #             @sim.send( :transitions ).Ts.first.codomain.names.must_equal [:A]
-#             @sim.simulation_method.must_equal :pseudo_euler
+#             @sim.simulation_method.must_equal :basic
 #             @sim.timed?.must_equal true
 #             @sim.core.timed?.must_equal true
 #             @sim.reset!
@@ -289,7 +289,7 @@ require_relative '../lib/y_petri'     # tested component itself
 #   it "should behave" do
 #     s = simulation
 #     assert ! s.timed?
-#     s.core.must_be_kind_of YPetri::Core::Timeless::PseudoEuler
+#     s.core.ancestors.must_include YPetri::Core::Timeless::Basic
 #     ds = s.recording
 #     ds.size.must_equal 6
 #     ds.events.must_equal [0, 1, 2, 3, 4, 5]
@@ -334,7 +334,7 @@ describe "timed simulation" do
   it "should behave" do
     places.map( &:marking ).must_equal [0.5, 0.5] # marking unaffected
     s = simulation
-    s.settings.must_equal( { method: :pseudo_euler, guarded: false,
+    s.settings.must_equal( { method: :basic, guarded: false,
                              step: 0.1, sampling: 5, time: 0..60 } ) 
     assert s.recording.to_csv.start_with?( ":event,:A,:B\n" +
                                            "0.0,0.5,0.5\n" +

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: y_petri
 version: !ruby/object:Gem::Version
-  version: 2.3.11
+  version: 2.3.12
 platform: ruby
 authors:
 - boris
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-05 00:00:00.000000000 Z
+date: 2015-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -145,15 +145,13 @@ files:
 - lib/y_petri/core.rb
 - lib/y_petri/core/guarded.rb
 - lib/y_petri/core/timed.rb
+- lib/y_petri/core/timed/basic.rb
 - lib/y_petri/core/timed/euler.rb
 - lib/y_petri/core/timed/gillespie.rb
-- lib/y_petri/core/timed/methods.rb
-- lib/y_petri/core/timed/pseudo_euler.rb
-- lib/y_petri/core/timed/quasi_euler.rb
 - lib/y_petri/core/timed/runge_kutta.rb
+- lib/y_petri/core/timed/ticked.rb
 - lib/y_petri/core/timeless.rb
-- lib/y_petri/core/timeless/methods.rb
-- lib/y_petri/core/timeless/pseudo_euler.rb
+- lib/y_petri/core/timeless/basic.rb
 - lib/y_petri/dsl.rb
 - lib/y_petri/fixed_assets.rb
 - lib/y_petri/net.rb

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

@@ -1,23 +0,0 @@
-# encoding: utf-8
-
-# Timed simulation core.
-# 
-module YPetri::Core::Timed
-  require_relative 'euler'
-  require_relative 'pseudo_euler' # t transitions firing after each step
-  require_relative 'quasi_euler' # t transitions firing after each time tick
-  require_relative 'gillespie'
-  require_relative 'runge_kutta'
-
-  module Methods
-    def method_init
-      extend case simulation_method
-             when :euler then Euler
-             when :pseudo_euler then PseudoEuler
-             when :quasi_euler then QuasiEuler
-             when :gillespie then Gillespie
-             when :runge_kutta then RungeKutta
-             else fail TypeError, "Unknown timed simulation method: #{method}!" end
-    end
-  end
-end

data/lib/y_petri/core/timeless/methods.rb

@@ -1,15 +0,0 @@
-# encoding: utf-8
-
-# Timed simulation core.
-# 
-module YPetri::Core::Timeless
-  require_relative 'pseudo_euler'
-
-  module Methods
-    def method_init
-      extend case simulation_method
-             when :pseudo_euler then PseudoEuler
-             else fail TypeError, "Unknown timeless simulation method: #{method}!" end
-    end
-  end
-end

data/lib/y_petri/core/timeless/pseudo_euler.rb

@@ -1,14 +0,0 @@
-# encoding: utf-8
-
-# Implicit Euler for timeless nets.
-#
-module YPetri::Core::Timeless::PseudoEuler
-  # Method #step! for timeless +pseudo_euler+ method. Simply, timeless
-  # transitions fire simultaneously, after which, A transitions (if any) fire.
-  # 
-  def step!
-    increment_marking_vector Δ
-    assignment_transitions_all_fire!
-    alert!
-  end
-end # module YPetri::Core::Timeless::PseudoEuler