y_petri 2.0.3 → 2.0.7

data/lib/y_petri/version.rb

@@ -1,4 +1,4 @@
 module YPetri
-  VERSION = "2.0.3"
+  VERSION = "2.0.7"
   DEBUG = false
 end

data/lib/y_petri/workspace/parametrized_subclassing.rb

@@ -2,25 +2,20 @@
 module YPetri::Workspace::ParametrizedSubclassing
   def initialize
     # Parametrized subclasses of Place, Transition and Net.
-    @Place = place_subclass = Class.new YPetri::Place
+    @Place = place_subclass = Class.new( YPetri::Place )
     @Transition = transition_subclass = Class.new YPetri::Transition
     @Net = net_subclass = Class.new YPetri::Net
 
-    # Now dependency injection: Let's tell these subclasses to work together.
-    [ @Place, @Transition, @Net ].each { |klass|
-      klass.class_exec {
-        # redefine their Place, Transition, Net method
+    # Make them namespaces and inject dependencies:
+    [ @Place, @Transition, @Net ].each do |klass|
+      klass.namespace!.class_exec do # make'em work together
         define_method :Place do place_subclass end
         define_method :Transition do transition_subclass end
         define_method :Net do net_subclass end
-        # I am not sure whether the following line is necessary. Place(),
-        # Transition() and Net() methods, which have just been redefined,
-        # are originally defined as private in klass. Is it necessary to
-        # declare them private explicitly again after redefining?
-        private :Place, :Transition, :Net
-      }
-    }
+        private :Place, :Transition, :Net # Redeclare private after redef???
+      end
+    end
 
-    super # Parametrized subclassing achieved, proceed ahead normally.
+    super # param. subclassing achieved, proceed ahead normally
   end # def initialize
 end # module YPetri::Workspace::ParametrizedSubclassing

data/lib/y_petri/workspace/simulation_related_methods.rb

@@ -137,15 +137,18 @@ module YPetri::Workspace::SimulationRelatedMethods
   #
   # * default_ss = { step_size: 0.1, sampling_period: 5, target_time: 60 }
   # 
-  def new_timed_simulation( settings={} ); st = settings
-    net_ɪ = net( st[:net] || self.Net::Top )
-    cc_id = st.may_have( :cc, syn!: :clamp_collection ) || :Base
-    imc_id = st.may_have( :imc, syn!: :initial_marking_collection ) || :Base
-    ssc_id = st.may_have( :ssc,  syn!: :simulation_settings_collection ) || :Base
+  def new_timed_simulation( net: Net()::Top, **nn )
+    net_ɪ = net( net )
+    nn.may_have :cc, syn!: :clamp_collection
+    nn.may_have :imc, syn!: :initial_marking_collection
+    nn.may_have :ssc, syn!: :simulation_settings_collection
+    cc_id = nn.delete( :cc ) || :Base
+    imc_id = nn.delete( :imc ) || :Base
+    ssc_id = nn.delete( :ssc ) || :Base
 
     # simulation key
-    key = settings.may_have( :ɴ, syn!: :name ) || # either explicit
-      { net: net_ɪ, cc: cc_id, imc: imc_id, ssc: ssc_id } # or constructed
+    key = nn.may_have( :ɴ, syn!: :name ) || # either explicit
+      { net: net_ɪ, cc: cc_id, imc: imc_id, ssc: ssc_id }.merge( nn ) # or constructed
 
     # Let's clarify what we got so far.
     simulation_settings = self.ssc( ssc_id )
@@ -173,9 +176,8 @@ module YPetri::Workspace::SimulationRelatedMethods
     else err.( [0, 1], " and #{missing.size-2} more places" ) end
 
     # Finally, create and return the simulation
-    @simulations[ key ] =
-      net_ɪ.new_timed_simulation( simulation_settings
-                                    .merge( initial_marking: im_hash,
-                                            place_clamps: clamp_hash ) )
+    named_args = simulation_settings.merge( initial_marking: im_hash,
+                                            marking_clamps: clamp_hash ).merge( nn )
+    @simulations[ key ] = net_ɪ.new_timed_simulation **named_args
   end # def new_timed_simulation
 end # module YPetri::Workspace::SimulationRelatedMethods

data/lib/y_petri.rb

@@ -7,6 +7,7 @@ require 'y_support/respond_to'
 require 'y_support/name_magic'
 require 'y_support/unicode'
 require 'y_support/typing'
+require 'y_support/conscience'; include Conscience
 require 'y_support/core_ext/hash'
 require 'y_support/core_ext/array'
 require 'y_support/stdlib_ext/matrix'
@@ -50,6 +51,8 @@ module YPetri
       target_time: 60 }
   end
 
+  GuardError = Class.new TypeError
+
   def self.included( receiver )
     # receiver.instance_variable_set :@YPetriManipulator, Manipulator.new
     # puts "included in #{receiver}"
@@ -64,7 +67,7 @@ module YPetri
 
   delegate( :workspace, to: :y_petri_manipulator )
 
-  # Petri net-related methods.
+  # Petri net aspect.
   delegate( :Place, :Transition, :Net,
             :place, :transition, :pl, :tr,
             :places, :transitions, :nets,
@@ -76,7 +79,7 @@ module YPetri
             :net_point_set,
             to: :y_petri_manipulator )
 
-  # Simulation-related methods.
+  # Simulation aspect.
   delegate( :simulation_point, :ssc_point, :cc_point, :imc_point,
             :simulation_selection, :ssc_selection,
             :cc_selection, :imc_selection,
@@ -99,7 +102,9 @@ module YPetri
             :simulation_settings_collection, :ssc,
             :clamp,
             :initial_marking,
-            :set_step, :set_time, :set_sampling,
+            :set_step, :set_step_size,
+            :set_time, :set_target_time,
+            :set_sampling,
             :set_simulation_method,
             :new_timed_simulation,
             :run!,

data/test/place_test.rb

@@ -0,0 +1,83 @@
+#! /usr/bin/ruby
+# -*- coding: utf-8 -*-
+
+require 'minitest/spec'
+require 'minitest/autorun'
+require_relative '../lib/y_petri'     # tested component itself
+# require 'y_petri'
+# require 'sy'
+
+describe YPetri::Place do
+  before do
+    @pç = pç = Class.new YPetri::Place
+    @p = pç.new! default_marking: 3.2,
+                 marking: 1.1,
+                 quantum: 0.1,
+                 name: "P1"
+  end
+
+  it "should support #name" do
+    assert_respond_to @p, :name
+    assert_equal @p.name, :P1
+  end
+
+  it "should have marking and related methods" do
+    @p.marking.must_equal 1.1 # Attention, #marking overloaded with guard setup!
+    @p.quantum.must_equal 0.1
+    @p.add 1
+    @p.value.must_equal 2.1   # near-alias of #marking (no guard setup)
+    @p.subtract 0.5
+    @p.m.must_equal 1.6       # alias of #value
+    @p.reset_marking
+    @p.marking.must_equal 3.2
+    @p.marking = 42
+    @p.m.must_equal 42
+    @p.m = 43
+    @p.m.must_equal 43
+    @p.value = 44
+    @p.m.must_equal 44
+  end
+
+  it "should have decent #inspect and #to_s methods" do
+    assert @p.inspect.start_with? "#<Place:"
+    assert @p.to_s.start_with? "#{@p.name}["
+  end
+
+  it "should have arc getter methods" do
+    @p.upstream_arcs.must_equal []
+    @p.upstream_transitions.must_equal [] # alias of #upstream_arcs
+    @p.ϝ.must_equal []                    # alias of #upstream_arcs
+    @p.downstream_arcs.must_equal []
+    @p.downstream_transitions.must_equal [] # alias of #downstream_arcs
+    @p.arcs.must_equal [] # all arcs
+    @p.precedents.must_equal []
+    @p.upstream_places.must_equal [] # alias for #precedents
+    @p.dependents.must_equal []
+    @p.downstream_places.must_equal [] # alias for #dependents
+  end
+
+  it "should have convenience methods to fire surrounding transitions" do
+    assert_respond_to @p, :fire_upstream
+    assert_respond_to @p, :fire_upstream!
+    assert_respond_to @p, :fire_downstream
+    assert_respond_to @p, :fire_downstream!
+    assert_respond_to @p, :fire_upstream_recursively
+    assert_respond_to @p, :fire_downstream_recursively
+  end
+
+  it "should have guard mechanics" do
+    @p.guards.size.must_equal 2 # working automatic guard construction
+    g1, g2 = @p.guards
+    g1.assertion.must_include "number"
+    g2.assertion.must_include "complex"
+    begin; g1.validate 11.1; g2.validate 11.1; @p.guard.( 11.1 ); :nothing_raised
+    rescue; :error end.must_equal :nothing_raised
+    -> { g2.validate Complex( 1, 1 ) }.must_raise YPetri::GuardError
+    @p.marking "must be in 0..10" do |m| fail unless ( 0..10 ) === m end
+    @p.guards.size.must_equal 3
+    g = @p.federated_guard_closure
+    -> { g.( 11.1 ) }.must_raise YPetri::GuardError
+    @p.marking = -1.11
+    -> { @p.guard! }.must_raise YPetri::GuardError
+  end
+end

data/test/transition_test.rb

@@ -0,0 +1,325 @@
+#! /usr/bin/ruby
+# -*- coding: utf-8 -*-
+
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'y_support/typing'
+
+require_relative '../lib/y_petri'     # tested component itself
+
+# require 'y_petri'
+# require 'sy'
+
+# **************************************************************************
+# Test of Transition class, part I.
+# **************************************************************************
+#
+describe ::YPetri::Transition do
+  before do
+    @ç = ç = Class.new ::YPetri::Transition
+    @pç = pç = Class.new ::YPetri::Place
+    [ ç, pç ].each do |ç|
+      ç.class_exec {
+        define_method :Place do pç end
+        define_method :Transition do ç end
+        private :Place, :Transition
+      }
+    end
+    @p1 = pç.new default_marking: 1.0
+    @p2 = pç.new default_marking: 2.0
+    @p3 = pç.new default_marking: 3.0
+    @p4 = pç.new default_marking: 4.0
+    @p5 = pç.new default_marking: 5.0
+  end
+
+  describe "ts transitions (timeless nonstoichiometric)" do
+    # Note: ts transitions require a function, and thus are always functional
+    before do
+      @t1 = @ç.new codomain: [ @p1, @p3 ], domain: @p2, action: -> a { [ a, a ] }
+      # saying that the transition is timed saves the day here:
+      @t2 = @ç.new codomain: [ @p1, @p3 ], action: -> t { [ t, t ] }, timed: true
+      # Only when the domain is unary, is the closure allowed to be timeless:
+      @t3 = @ç.new codomain: [ @p1, @p3 ], action: -> t { [ t, t ] }, timed: false, domain: [ @p2 ]
+      # With nullary action closure, timeless is implied, so this is allowed
+      @t4 = @ç.new action: -> { [ 0.5, 0.5 ] }, codomain: [ @p1, @p3 ]
+      # ... also for stoichiometric variety
+      @t5 = @ç.new action: -> { 0.5 }, codomain: [ @p1, @p3 ], s: [ 1, 1 ]
+    end
+
+    it "should raise errors for bad parameters" do
+      # omitting the domain should raise ArgumentError about too much ambiguity:
+      -> { @ç.new codomain: [ @p1, @p3 ], action: -> t { [ t, t ] } }
+        .must_raise ArgumentError
+      # saying that the transition is timeless points to a conflict:
+      -> { @ç.new codomain: [ @p1, @p3 ], action: -> t { [ t, t ] }, timeless: true }
+        .must_raise ArgumentError
+    end
+
+    it "should initialize and perform" do
+      @t1.domain.must_equal [@p2]
+      @t1.action_arcs.must_equal [@p1, @p3]
+      assert @t1.functional?
+      assert @t1.timeless?
+      assert @t2.timed?
+      assert [@t3, @t4, @t5].all? { |t| t.timeless? }
+      assert @t2.rateless?
+      # Now let's flex them:
+      @t1.fire!
+      [@p1.m, @p3.m].must_equal [3, 5]
+      @t3.fire!
+      [@p1.m, @p3.m].must_equal [5, 7]
+      @t4.fire!
+      [@p1.m, @p3.m].must_equal [5.5, 7.5]
+      @t5.fire!
+      [@p1.m, @p3.m].must_equal [6, 8]
+      # now t2 for firing requires delta time
+      @t2.fire! 1
+      [@p1.m, @p3.m].must_equal [7, 9]
+      @t2.fire! 0.1
+      [@p1.m, @p3.m ].must_equal [7.1, 9.1]
+      # let's change @p2 marking
+      @p2.m = 0.1
+      @t1.fire!
+      assert_in_epsilon 7.2, @p1.marking, 1e-9
+      assert_in_epsilon 9.2, @p3.marking, 1e-9
+      # let's test #domain_marking, #codomain_marking, #zero_action
+      @t1.codomain_marking.must_equal [@p1.m, @p3.m]
+      @t1.domain_marking.must_equal [@p2.m]
+      @t1.zero_action.must_equal [0, 0]
+    end
+  end
+
+  describe "Tsr transitions (timed rateless non-stoichiometric)" do
+    #LATER: To save time, I omit the full test suite.
+  end
+
+  describe "tS transitions (timeless stoichiometric)" do
+    describe "functionless tS transitions" do
+      # For functionless tS transitions, stoichiometric vector must be given,
+      # from which the action closure is then generated.
+
+      before do
+        # tS transition with only stoichiometric vector, as hash
+        @ftS1 = @ç.new stoichiometry: { @p1 => 1 }
+        # tS transition with only stoichiometric vector, as array + codomain
+        @ftS2 = @ç.new stoichiometry: 1, codomain: @p1
+        # :stoichiometry keyword is aliased as :s
+        @ftS3 = @ç.new s: 1, codomain: @p1
+        # :codomain is aliased as :action_arcs
+        @ftS4 = @ç.new s: 1, action_arcs: @p1
+        # square brackets (optional for size 1 vectors)
+        @ftS5 = @ç.new s: [ 1 ], downstream: [ @p1 ]
+        # another alias of :codomain is :downstream_places
+        @ftS6 = @ç.new s: [ 1 ], downstream_places: [ @p1 ]
+        # And now, collect all of the above:
+        @tt = @ftS1, @ftS2, @ftS3, @ftS4, @ftS5, @ftS6
+      end
+
+      it "should work" do
+        # ...should be the same, having a single action arc:
+        assert @tt.all? { |t| t.action_arcs == [@p1] }
+        # timeless:
+        assert @tt.all? { |t| t.timeless? }
+        # rateless:
+        assert @tt.all? { |t| t.rateless? }
+        assert @tt.all? { |t| not t.has_rate? }
+        # no assignment action
+        assert @tt.all? { |t| not t.assignment_action? }
+        # not considered functional
+        assert @tt.all? { |t| t.functionless? }
+        assert @tt.all? { |t| not t.functional? }
+        # and having nullary action closure
+        assert @tt.all? { |t| t.action_closure.arity == 0 }
+        # the transitions should be able to #fire!
+        @ftS1.fire!
+        # the difference is apparent: marking of place @p1 jumped to 2:
+        @p1.marking.must_equal 2
+        # but should not #fire (no exclamation mark) unless cocked
+        assert !@ftS1.cocked?
+        @ftS1.fire
+        @p1.marking.must_equal 2
+        # cock it
+        @ftS1.cock
+        assert @ftS1.cocked?
+        # uncock again, just to test cocking
+        @ftS1.uncock
+        assert @ftS1.uncocked?
+        @ftS1.cock
+        assert !@ftS1.uncocked?
+        @ftS1.fire
+        @p1.marking.must_equal 3
+        # enough playing, we'll reset @p1 marking
+        @p1.reset_marking
+        @p1.marking.must_equal 1
+        # #action
+        assert @tt.all? { |t| t.action == [1] }
+        # #zero_action
+        assert @tt.all? { |t| t.zero_action }
+        # #action_after_feasibility_check
+        assert @tt.all? { |t| t.action_after_feasibility_check == [1] }
+        # #domain_marking
+        assert @tt.all? { |t| t.domain_marking == [] }
+        # #codomain_marking
+        assert @tt.all? { |t| t.codomain_marking == [@p1.m] }
+        # #enabled?
+        @p1.m.must_equal 1
+        @p1.guard.( 1 ).must_equal true
+        @tt.each { |t| t.enabled?.must_equal true }
+      end
+    end
+
+    describe "functional tS transitions" do
+      # Closure supplied to tS transitions governs their action.
+
+      before do
+        # stoichiometry given as hash
+        @FtS1 = @ç.new action_closure: ->{ 1 }, s: { @p1 => 1 }
+        # :action_closure has alias :action
+        @FtS2 = @ç.new action: ->{ 1 }, s: { @p1 => 1 }
+        # stoichiometry given as array of coefficients + codomain
+        @FtS3 = @ç.new s: 1, codomain: @p1, action: ->{ 1 }
+        # Specifying +timed: false+ as well as +timeless: true+ should be OK.
+        @FtS4 = @ç.new s: { @p1 => 1 }, action: ->{ 1 }, timed: false
+        @FtS5 = @ç.new s: { @p1 => 1 }, action: ->{ 1 }, timeless: true
+        # Even together in one statement:
+        @FtS6 = @ç.new s: { @p1 => 1 }, action: ->{ 1 }, timed: false, timeless: true
+        @tt = @FtS1, @FtS2, @FtS3, @FtS4, @FtS5, @FtS6
+      end
+
+      it "should reject bad parameters" do
+        # # +timed: true+ should raise a complaint:
+        # -> { @ç.new s: { @p1 => 1 }, action: ->{ 1 }, timed: true }
+        #   .must_raise ArgumentError # constraint relaxed?
+      end
+
+      it "should init and perform" do
+        assert @tt.all? { |t| t.action_arcs == [ @p1 ] }
+        assert @tt.all? { |t| t.timeless? }
+        assert @tt.all? { |t| not t.has_rate? }
+        assert @tt.all? { |t| t.rateless? }
+        assert @tt.all? { |t| not t.assignment_action? }
+        assert @tt.all? { |t| not t.functionless? }
+        assert @tt.all? { |t| t.functional? }
+        # and having nullary action closure
+        assert @tt.all? { |t| t.action_closure.arity == 0 }
+        # the transitions should be able to #fire!
+        @FtS1.fire!
+        # no need for more testing here
+      end
+    end
+  end
+
+  describe "TSr transitions (timed rateless stoichiometric)" do
+    # Sr transitions have an action closure, require a function block, and thus
+    # are always functional. Their closure must take Δt as its first argument.
+
+    #LATER: To save time, I omit the tests of TSr transitions for now.
+  end
+
+  describe "sR transitions (nonstoichiometric with rate)" do
+    # Expect a function block with arity equal to their domain size, and output
+    # arity equal to the codomain size.
+
+    #LATER: To save time, I omit the full test suite.
+  end
+
+  describe "SR transitions (stoichiometric with rate)" do
+    before do
+      # This should give standard mass action by magic:
+      @SR1 = @ç.new s: { @p1 => -1, @p2 => -1, @p4 => 1 }, rate: 0.1
+      # While this has custom closure:
+      @SR2 = @ç.new s: { @p1 => -1, @p3 => 1 }, rate: -> a { a * 0.5 }
+      # While this one even has domain explicitly specified:
+      @SR3 = @ç.new s: { @p1 => -1, @p2 => -1, @p4 => 1 },
+                    upstream_arcs: @p3, rate: -> a { a * 0.5 }
+    end
+
+    it "should init and work" do
+      @SR1.has_rate?.must_equal true
+      @SR1.upstream_arcs.must_equal [@p1, @p2]
+      @SR1.action_arcs.must_equal [@p1, @p2, @p4]
+      @SR2.domain.must_equal [@p1]
+      @SR2.action_arcs.must_equal [@p1, @p3]
+      @SR3.domain.must_equal [@p3]
+      @SR3.action_arcs.must_equal [@p1, @p2, @p4]
+      # and flex them
+      @SR1.fire! 1.0
+      [@p1, @p2, @p4].map( &:marking ).must_equal [0.8, 1.8, 4.2]
+      @SR2.fire! 1.0
+      [@p1, @p3].map( &:marking ).must_equal [0.4, 3.4]
+      # the action t3 cannot fire with delta time 1.0
+      -> { @SR3.fire! 1.0 }.must_raise RuntimeError
+      [@p1, @p2, @p3, @p4].map( &:marking ).must_equal [0.4, 1.8, 3.4, 4.2]
+      # but it can fire with eg. delta time 0.1
+      @SR3.fire! 0.1
+      assert_in_epsilon 0.23, @p1.marking, 1e-15
+      assert_in_epsilon 1.63, @p2.marking, 1e-15
+      assert_in_epsilon 3.4, @p3.marking, 1e-15
+      assert_in_epsilon 4.37, @p4.marking, 1e-15
+    end
+  end
+end
+
+
+# **************************************************************************
+# Test of mutual knowedge of upstream/downstream arcs of places/transitions.
+# **************************************************************************
+#
+describe "upstream and downstream reference mτs of places and transitions" do
+  before do
+    # skip "to speed up testing"
+    @tç = tç = Class.new YPetri::Transition
+    @pç = pç = Class.new YPetri::Place
+    [ tç, pç ].each { |ç|
+      ç.class_exec {
+        define_method :Place do pç end
+        define_method :Transition do tç end
+        private :Place, :Transition
+      }
+    }
+    @a = @pç.new( default_marking: 1.0 )
+    @b = @pç.new( default_marking: 2.0 )
+    @c = @pç.new( default_marking: 3.0 )
+  end
+
+  describe "Place" do
+    it "should have #register_ustream/downstream_transition methods" do
+      @t1 = @tç.new s: {}
+      @a.instance_variable_get( :@upstream_arcs ).must_equal []
+      @a.instance_variable_get( :@downstream_arcs ).must_equal []
+      @a.send :register_upstream_transition, @t1
+      @a.instance_variable_get( :@upstream_arcs ).must_equal [ @t1 ]
+    end
+  end
+
+  describe "upstream and downstream reference methods" do
+    before do
+      @t1 = @tç.new s: { @a => -1, @b => 1 }, rate: 1
+    end
+
+    it "should show on the referencers" do
+      @a.upstream_arcs.must_equal [@t1]
+      @b.downstream_arcs.must_equal []
+      @b.ϝ.must_equal [@t1]
+      @t1.upstream_arcs.must_equal [@a]
+      @t1.action_arcs.must_equal [@a, @b]
+    end
+  end
+
+  describe "assignment action transitions" do
+    before do
+      @p = @pç.new default_marking: 1.0
+      @t = @tç.new codomain: @p, action: -> { 1 }, assignment_action: true
+    end
+
+    it "should work" do
+      @p.marking = 3
+      @p.marking.must_equal 3
+      assert @t.assignment_action?
+      @t.domain.must_equal []
+      @t.action_closure.arity.must_equal 0
+      @t.fire!
+      @p.marking.must_equal 1
+    end
+  end # context assignment action transiotions
+end