y_petri 2.4.0 → 2.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ef666cef4bef63ff531f923b5b5c15dbf44f3d01
-  data.tar.gz: 39b9e0478d5fbe58ea0f351d930c307acdeab419
+  metadata.gz: fb7a7b5033fa23e8fbdaee627d1864722a31f850
+  data.tar.gz: b17971ab72080978c0877a281e6a22fd7dcef2df
 SHA512:
-  metadata.gz: c8c52cbb6efd249b118a8e9347a478725d2916354c894a63b1ef6da8bc7e517f0af702a0479cc39b3ee334b0579d697ce7926fb2e2de03850c8707aaeebea457
-  data.tar.gz: 8a3ed7e54e271be653a563401abeeebb8409e5c34b76eeba6f8ccc49af59c9e86d3427917840ae0adbab28f4c4f93d92e318acb8776a313ff4f915f856081bad
+  metadata.gz: df9453ff5bd03c744158b2d8f848c7700ea3cdc80f0c3eb6fb64c409a0436eb7bae5e7538ed86f96c3e759acd4b68c79d9b07cc0045bad0718d0ae7ea5d761ea
+  data.tar.gz: dd0569b0b5a0b402a78b1130b7805d3d8202ccd8219ddcdb35a18c7a10f4c479d12b4e4216f1a6c8cce84ff314ce18d228ab803e2f89d785682719d517901c2e

data/lib/y_petri/core.rb

@@ -75,7 +75,7 @@ module YPetri::Core
 
   delegate :alert!, to: :recorder
 
-  # Delta for free places from timeless transitions.
+  # Delta contribution to free places by timeless transitions.
   # 
   def delta_timeless
     delta_ts + delta_tS
@@ -112,6 +112,18 @@ module YPetri::Core
     simulation.increment_marking_vector_closure.( delta )
   end
 
+  # For now, alias method for #increment_marking_vector.
+  # TODO: I already said to myself that I want the core not to rely
+  # on the simulation's increment_marking_vector_closure.
+  #
+  def increment_free_vector( by: fail( "No delta given!" ) )
+    print '.'
+    simulation.increment_marking_vector_closure.( by )
+    # Also, here it is not clear that #increment_marking_vector_closure
+    # returns a closure that expects only Δ for free places. Should have
+    # better mnemonic name.
+  end
+
   # Fires all the assignment transitions.
   # 
   def fire_all_assignment_transitions!

data/lib/y_petri/core/timeless.rb

@@ -31,10 +31,5 @@ class YPetri::Core::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.
-  # 
-  def Δ
-    delta
-  end
+  alias Δ delta
 end # module YPetri::Core::Timeless

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

@@ -10,7 +10,7 @@ module YPetri::Core::Timeless::Basic
   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
+    increment_free_vector by: Δ
     # Fire all the assignment transitions in their order.
     fire_all_assignment_transitions!
     # before: assignment_transitions_all_fire!

data/lib/y_petri/simulation/timed.rb

@@ -349,9 +349,13 @@ module YPetri::Simulation::Timed
               else
                 YPetri::Core::Timed.new( simulation: self, method: method, guarded: false )
               end
+      # TODO: But why am I doing it like this? Did I want to emphasize the standalone
+      # nature of Core class? Maybe... And maybe I did it so that the runge-kutta method
+      # with its @rk_core instance variable instead of @core does not have @core and #core.
+      # In this manner, I'm forcing myself to rethink Simulation class.
       singleton_class.class_exec do
         attr_reader :core
-        delegate :simulation_method,
+        delegate :simulation_method, # this looks quite redundant with simulation.rb
                  :step!,
                  :firing_vector_tS,
                  to: :core
@@ -370,5 +374,5 @@ module YPetri::Simulation::Timed
                 else
                   Recorder().new( sampling: settings[:sampling] )
                 end
-  end
+  end # def init
 end # module YPetri::Simulation::Timed

data/lib/y_petri/simulation/timeless.rb

@@ -27,26 +27,39 @@ module YPetri::Simulation::Timeless
     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
-                YPetri::Core::Timeless
-                  .new( simulation: self, method: method, guarded: true )
-              else
-                YPetri::Core::Timeless
-                  .new( simulation: self, method: method, guarded: false )
-              end
-      @recorder = if features_to_record then 
-                    # we'll have to figure out features
-                    ff = case features_to_record
-                         when Array then
-                           net.State.Features
-                             .infer_from_nodes( features_to_record )
-                         when Hash then
-                           net.State.features( features_to_record )
-                         end
-                    Recorder().new( features: ff )
-                  else
-                    Recorder().new # init the recorder
-                  end
+    param_class( { Recorder: Recorder }, with: { simulation: self } )
+    @core = if @guarded then
+              YPetri::Core::Timeless
+                .new( simulation: self, method: method, guarded: true )
+            else
+              YPetri::Core::Timeless
+                .new( simulation: self, method: method, guarded: false )
+            end
+      
+    # TODO: But why am I doing it like this? Did I want to emphasize the standalone
+    # nature of Core class? Maybe... And maybe I did it so that the runge-kutta method
+    # with its @rk_core instance variable instead of @core does not have @core and #core.
+    # In this manner, I'm forcing myself to rethink Simulation class.
+    singleton_class.class_exec do
+      attr_reader :core
+      delegate :simulation_method, # this looks quite redundant with simulation.rb
+               :step!,
+               :firing_vector_tS,
+               to: :core
     end
+    
+    @recorder = if features_to_record then 
+                  # we'll have to figure out features
+                  ff = case features_to_record
+                       when Array then
+                         net.State.Features
+                           .infer_from_nodes( features_to_record )
+                       when Hash then
+                         net.State.features( features_to_record )
+                       end
+                  Recorder().new( features: ff )
+                else
+                  Recorder().new # init the recorder
+                end
+  end # def init
 end # module YPetri::Simulation::Timeless

data/lib/y_petri/version.rb

@@ -1,4 +1,4 @@
 module YPetri
-  VERSION = "2.4.0"
+  VERSION = "2.4.2"
   DEBUG = false
 end

data/lib/y_petri/world/simulation_aspect.rb

@@ -321,7 +321,7 @@ module YPetri::World::SimulationAspect
   #
   # * default_ss = { step_size: 0.1, sampling_period: 5, target_time: 60 }
   # 
-  def new_simulation( net: Net()::Top, **nn )
+  def new_simulation( net: Net().instance( :Top ), **nn )
     net_inst = net( net )
     nn.may_have :cc, syn!: :clamp_collection
     nn.may_have :imc, syn!: :initial_marking_collection
@@ -330,13 +330,13 @@ module YPetri::World::SimulationAspect
     imc_id = nn.delete( :imc ) || :Base
     ssc_id = nn.delete( :ssc ) || :Base
     # Construct the simulation key:
-    key = if nn.has? :name, syn!: :ɴ then # explicit key (name)
+    key = if nn.has? :name, syn!: :ɴ then  # explicit key (name)
             nn[:name]
-          else                       # constructed key
+          else                             # constructed key
             {}.merge( net: net_inst,
                        cc: cc_id,
-                       imc: imc_id,
-                       ssc: ssc_id )
+                      imc: imc_id,
+                      ssc: ssc_id )
               .merge( nn )
           end
     # Let's clarify what we got so far.

data/test/core_test.rb

@@ -7,8 +7,10 @@ require_relative '../lib/y_petri'     # tested component itself
 # require 'y_petri'
 # require 'sy'
 
-describe "use of timed and timeless core" do
+describe "core" do
   before do
+    @timed_core_class = YPetri::Core::Timed
+    @timeless_core_class = YPetri::Core::Timeless
     # set up a user of core, which will imitate some of the needs
     # of the Simulation class, or be an actual instance of that class
   end
@@ -22,5 +24,40 @@ describe "use of timed and timeless core" do
     # number of steps or until some other condition is fulfilled, or
     # step backward, or even run backward, if the system allows such thing
     # at all.
+    @timed_core_class::METHODS.keys.must_include :basic
+    @timeless_core_class::METHODS.keys.must_include :basic
+  end
+
+  describe "timed core" do
+  end
+
+  describe "timeless core" do
+    describe "basic method" do
+      before do
+        # @timeless_core_class.new( method: :basic )
+        # TODO: The above logically fails, because core now
+        # requires simulation. But newly, a core should no
+        # longer require a simulation. It should simply receive
+        # initial marking vector, information about places
+        # (including clamped places and their clamps), information
+        # above processes (ie. transitions). Surely, this looks
+        # like a third redundant layer of place and transition
+        # representations (the first two are in Net and Simulation
+        # class). But it serves me right since I want to do things
+        # properly :-) Core represents a simulation machine,
+        # hardware. Of course, I have no hardware other than
+        # Ruby itself. I am not even able to compile the simulation
+        # into C. It is quite imaginable that Simulation would
+        # be flexible about using cores and simulation methods
+        # to do what the user requires it to do, while cores would
+        # be more inflexible, method specific and machine specific.
+        # So Core is a machine abstraction, while Simulation is the
+        # abstraction of what the user might require from a Simulation.
+        # Anyway a good way to kill time.
+      end
+
+      it "should behave" do
+      end
+    end
   end
 end

data/test/examples/issues.rb

@@ -0,0 +1,71 @@
+#encoding: utf-8
+
+# Found things that do not work with YPetri. 
+
+require 'y_petri'
+include YPetri
+
+A = Place default_marking: 5
+B = Place default_marking: 5
+C = Place default_marking: 0
+D = Place default_marking: 0
+
+T1 = Transition stoichiometry: { A: -1, B: -1, C: 1 }
+T2 = Transition stoichiometry: { C: -1, D: 1 }
+
+net.timed? # The net is timeless
+
+new_simulation # This produces timed simulation (same as run!)
+
+net.simulation # While this produces timeless simulation.
+
+# This is happening because I have deleted :core selector from
+# Simulation class code. I did this because when adding Runge-Kutta
+# method, I construct instance-specific instance variable @rk_core
+# instead of @core.
+
+# This, again, will produce timed simulation.
+net.simulation **ssc
+
+# Simulation#initialize has hard times deciding whether it is
+# constructing timed or timeless simulation. When it sees time
+# mentioned (:step, :sampling, :time parameters are all set)
+# in ssc, it decides to construct a timed simulation.
+#
+# When it does not see the time mentioned, it decides to construct
+# a timeless simulation. The decision is quite right when I merely
+# call net.simulation, because the net is actually quite timeless.
+#
+# But once I call for :basic simulation method ...
+#
+# Now I used to call :basic method :pseudo_euler, which would suggest
+# timed simulation. But timeless simulations also have :basic method
+# among them...
+#
+# The question is whether I should have timed and timeless methods
+# with same names...
+
+# I should keep at this and rethink the Simulation class
+
+# also, another problem
+# 
+# set_ssc :Hello
+# 
+# instead of trying to set the simulation settings collection
+# to the one named :Hello will cause the simulation settings
+# collection named :Base be set to :Hello
+
+simulation_settings_collection # alias ssc
+
+simulation_settings_collections
+
+set_simulation_settings_collection :Hello
+
+simulation_settings_collection # alias ssc
+
+simulation_settings_collections
+
+# This is obviously wrong. Whole idea of collections of clamps
+# and initial values and simulation settings is quite dated, it
+# dates back to the times when I was not at the top of my Ruby
+# proficiency yet. Maybe time to rethink World / Agent classes.

data/test/examples/manual_examples.rb

@@ -9,7 +9,7 @@ set_step 10
 set_target_time 600
 set_sampling 10
 # Euler with timeless transitions firing after each step:
-set_simulation_method :PseudoEuler
+set_simulation_method :basic
 
 A = Place m!: 1
 B = Place m!: 10
@@ -25,4 +25,4 @@ Transition name: :C_held_at_half_B,
            assignment: -> x { x / 2 }
 
 run!
-plot_recording
+recording.plot

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: y_petri
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.4.2
 platform: ruby
 authors:
 - boris
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-16 00:00:00.000000000 Z
+date: 2016-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -253,6 +253,7 @@ files:
 - test/examples/example_2.rb
 - test/examples/example_IV.rb
 - test/examples/example_VI_gillespie.rb
+- test/examples/issues.rb
 - test/examples/manual_examples.rb
 - test/net_test.rb
 - test/place_test.rb
@@ -305,6 +306,7 @@ test_files:
 - test/examples/example_2.rb
 - test/examples/example_IV.rb
 - test/examples/example_VI_gillespie.rb
+- test/examples/issues.rb
 - test/examples/manual_examples.rb
 - test/net_test.rb
 - test/place_test.rb