y_petri 2.0.15 → 2.1.3

data/lib/y_petri.rb

@@ -1,116 +1,64 @@
-require 'gnuplot'
-require 'csv'
-require 'graphviz'
-
-require 'y_support/local_object'
-require 'y_support/respond_to'
-require 'y_support/name_magic'
-require 'y_support/unicode'
-require 'y_support/typing'
-require 'y_support/try'
-require 'y_support/core_ext/hash'
-require 'y_support/core_ext/array'
-require 'y_support/stdlib_ext/matrix'
-require 'y_support/abstract_algebra'
-require 'y_support/kde'
+#encoding: utf-8
 
 require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/array/extract_options'
+require 'active_support/inflector'
+
+# The following are the Ruby libraries used by YPetri:
+require 'gnuplot'                      # used for graph visualization
+require 'csv'                          # not used at the moment
+require 'graphviz'                     # used for Petri net visualization
+
+# The following are the YSupport components used by YPetri:
+require 'y_support/local_object'       # object aware of its creation scope
+require 'y_support/respond_to'         # Symbol#~@ + RespondTo#===
+require 'y_support/name_magic'         # naming by assignment & more
+require 'y_support/unicode'            # ç means self.class
+require 'y_support/typing'             # run-time assertions
+require 'y_support/try'                # increased awareness in danger
+require 'y_support/core_ext'           # core extensions
+require 'y_support/stdlib_ext/matrix'  # matrix extensions
+require 'y_support/abstract_algebra'   # 
+require 'y_support/kde'                # popup file with kioclient
 
 require_relative 'y_petri/version'
+require_relative 'y_petri/fixed_assets'
+require_relative 'y_petri/world'
 require_relative 'y_petri/place'
 require_relative 'y_petri/transition'
 require_relative 'y_petri/net'
 require_relative 'y_petri/simulation'
-require_relative 'y_petri/workspace'
-require_relative 'y_petri/manipulator'
+require_relative 'y_petri/core'
+require_relative 'y_petri/agent'
+require_relative 'y_petri/dsl'
 
-# YPetri represents Petri net (PN) formalism.
+# YPetri represents Petri net (PN) formalims.
 #
-# A PN consists of places and transitions. There are also arcs, that is,
-# "arrows" connecting places and transitions, though arcs are not considered
-# first class citizens in YPetri.
+# A PN consists of places and transitions. There are also arcs, "arrows"
+# connecting places and transitions, but these are not considered first class
+# citizens in YPetri.
 #
-# At the time of PN execution (or simulation), transitions act upon places
-# and change their marking by placing or removing tokens as dictated by
-# their operation method ("function").
+# During PN execution (simulation), transitions act upon places and change their
+# marking by adding / removing tokens as dictated by their function -- more
+# precisely, their operation prescription. Borrowing more from the functional
+# terminology, I define domain an codomain of a PN transition in a similar way
+# to the functional domain and codomain.
 #
-# Hybrid Functional Petri Net formalism, motivated by modeling cellular
-# processes by their authors' Cell Illustrator software, explicitly
-# introduces the possibility of both discrete and continuous places and
-# transitions ('Hybrid'). YPetri does not emphasize this. Just like there is
-# fluid transition between Fixnum and Bignum, there should be fluid
-# transition between token amount representation as Integer (discrete) or
-# Float (continuous) - the decision should be on the simulator.
+# Hybrid Functional Petri Net (HFPN) formalism, motivated by the needs of
+# modeling of cellular processes, explicitly introduces the option of having
+# discrete as well as continuous places and transitions (therefrom "hybrid").
+# In YPetri, the emphasis is elsewhere. Just like in modern computer languages,
+# there is a fluid transition between Fixnum and Bignum, YPetri attempts for
+# similarly fluid transition between Integer (ie. discrete) and floating point
+# (ie. continuous) representation of token amounts and reaction speeds. Whole
+# discrete / continuous issue thus becomes the business of the simulator, not
+# the model.
 # 
 module YPetri
-  DEFAULT_SIMULATION_SETTINGS = lambda do
-    { step_size: 0.02,
-      sampling_period: 2,
-      time: 0..60 }
+  class << self
+    def included( receiver )
+      receiver.extend YPetri::DSL
+      receiver.delegate :y_petri_agent, to: "self.class"
+    end
   end
-
-  GuardError = Class.new TypeError
-
-  def self.included( receiver )
-    # receiver.instance_variable_set :@YPetriManipulator, Manipulator.new
-    # puts "included in #{receiver}"
-    receiver.module_exec {
-      define_method :y_petri_manipulator do
-        singleton_class.instance_variable_get :@YPetriManipulator or
-          ( puts "defining Manipulator for #{self} singleton class" if YPetri::DEBUG
-            singleton_class.instance_variable_set :@YPetriManipulator, Manipulator.new )
-      end
-    }
-  end
-
-  delegate( :workspace, to: :y_petri_manipulator )
-
-  # Petri net aspect.
-  delegate( :Place, :Transition, :Net,
-            :place, :transition, :pl, :tr,
-            :places, :transitions, :nets,
-            :pp, :tt, :nn,
-            :net_point,
-            :net_selection,
-            :net, :ne,
-            :net_point_reset,
-            :net_point_set,
-            to: :y_petri_manipulator )
-
-  # 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, :cc_names,
-            :initial_marking_collection_names, :imc_names,
-            :simulation_settings_collection_names, :ssc_names,
-            :set_clamp_collection, :set_cc,
-            :set_initial_marking_collection, :set_imc,
-            :set_simulation_settings_collection, :set_ssc,
-            :new_timed_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_manipulator )
 end

data/test/{manipulator_test.rb → agent_test.rb}

@@ -7,16 +7,16 @@ require_relative '../lib/y_petri'     # tested component itself
 # require 'y_petri'
 # require 'sy'
 
-describe ::YPetri::Manipulator do
+describe YPetri::Agent do
   before do
-    @m = ::YPetri::Manipulator.new
+    @m = YPetri::Agent.new
   end
   
   it "has net basic points" do
     # --- net point related assets ---
     @m.net_point_reset
-    @m.net_point_set @m.workspace.net( :Top )
-    @m.net.must_equal @m.workspace.Net::Top
+    @m.net_point_reset @m.world.net( :Top )
+    @m.net.must_equal @m.world.Net::Top
     # --- simulation point related assets ---
     @m.simulation_point.reset
     @m.simulation.must_equal nil
@@ -24,19 +24,19 @@ describe ::YPetri::Manipulator do
     # --- cc point related assets ---
     @m.cc_point.reset
     @m.cc_point.set :Base
-    @m.cc.must_equal @m.workspace.clamp_collection
+    @m.cc.must_equal @m.world.clamp_collection
     @m.cc.wont_equal :Base
     @m.cc_point.key.must_equal :Base
     # --- imc point related assets ---
     @m.imc_point.reset
     @m.imc_point.set :Base
-    @m.imc.must_equal @m.workspace.initial_marking_collection
+    @m.imc.must_equal @m.world.initial_marking_collection
     @m.imc.wont_equal :Base
     @m.imc_point.key.must_equal :Base
     # --- ssc point related assets ---
     @m.ssc_point.reset
     @m.ssc_point.set :Base
-    @m.ssc.must_equal @m.workspace.simulation_settings_collection
+    @m.ssc.must_equal @m.world.simulation_settings_collection
     @m.ssc.wont_equal :Base
     @m.ssc_point.key.must_equal :Base
   end
@@ -64,8 +64,8 @@ describe ::YPetri::Manipulator do
       @m.initial_marking_collections,
       @m.simulation_settings_collections ]
     .map( &:keys ).must_equal [[:Base]] * 3
-    @m.pp.must_equal []
-    @m.tt.must_equal []
+    @m.pn.must_equal []
+    @m.tn.must_equal []
     @m.nn.must_equal [ :Top ]       # ie. :Top net spanning whole workspace
   end
   
@@ -84,15 +84,17 @@ describe ::YPetri::Manipulator do
     
     it "works" do
       @m.run!
-      @m.simulation.places.must_equal [ @p, @q ]
-      @m.simulation.transitions.must_equal [ @decay_t, @constant_flux_t ]
-      @m.simulation.SR_tt.must_equal [ :Tp, :Tq ]
-      @m.simulation.sparse_stoichiometry_vector( :Tp )
+      @m.simulation.send( :places ).map( &:source )
+        .must_equal [ @p, @q ]
+      @m.simulation.send( :transitions ).map( &:source )
+        .must_equal [ @decay_t, @constant_flux_t ]
+      @m.simulation.nTS.must_equal [ :Tp, :Tq ]
+      @m.simulation.send( :transition, :Tp ).sparse_stoichiometry_vector
         .must_equal Matrix.column_vector( [-1, 0] )
-      @m.simulation.stoichiometry_matrix_for( @m.transitions ).column_size
-        .must_equal 2
-      @m.simulation.stoichiometry_matrix_for( @m.transitions ).row_size
-        .must_equal 2
+      @m.simulation.send( :S_transitions )
+        .stoichiometry_matrix.column_size.must_equal 2
+      @m.simulation.send( :S_transitions )
+        .stoichiometry_matrix.row_size.must_equal 2
       @m.simulation.flux_vector.row_size.must_equal 2
       # @m.plot_recording
     end

data/{lib/y_petri → test/examples}/demonstrator_2.rb

@@ -31,6 +31,7 @@ DeoxyU12P = Place m!: 0.0.µM
 DeoxyTMP = Place m!: 3.3.µM
 DeoxyT23P = Place m!: 5.0.µM
 Thymidine = Place m!: 0.5.µM
+
 TK1 = Place m!: 100_000.unit.( SY::MoleAmount ) / Cytoplasm_volume
 TYMS = Place m!: 100_000.unit.( SY::MoleAmount ) / Cytoplasm_volume
 RNR = Place m!: 100_000.unit.( SY::MoleAmount ) / Cytoplasm_volume

data/test/examples/example_2.rb

@@ -0,0 +1,16 @@
+#encoding: utf-8
+
+require 'y_petri'
+include YPetri
+
+A = Place( default_marking: 0.5 )
+B = Place( default_marking: 0.5 )
+A_pump = Transition( stoichiometry: { A: -1 }, rate: proc { 0.005 } )
+B_decay = Transition( stoichiometry: { B: -1 }, rate: 0.05 )
+net
+run!
+simulation
+places.map &:marking
+simulation.settings
+print_recording
+plot_state; nil

data/test/net_test.rb

@@ -1,170 +1,175 @@
 #! /usr/bin/ruby
-# -*- coding: utf-8 -*-
+# encoding: utf-8
 
 require 'minitest/spec'
 require 'minitest/autorun'
 require_relative '../lib/y_petri'     # tested component itself
 # require 'y_petri'
 # require 'sy'
+require_relative 'world_mock'
 
 describe YPetri::Net do
   before do
-    @tç = tç = Class.new YPetri::Transition
-    @pç = pç = Class.new YPetri::Place
-    @nç = nç = Class.new YPetri::Net
-    [ tç, pç, nç ].each { |ç|
-      ç.namespace!
-      ç.class_exec {
-        define_method :Place do pç end
-        define_method :Transition do tç end
-        define_method :Net do nç end
-        private :Place, :Transition, :Net
-      }
-    }
-    @p1 = pç.new ɴ: "A", quantum: 0.1, marking: 1.1
-    @p2 = pç.new ɴ: "B", quantum: 0.1, marking: 2.2
-    @p3 = pç.new ɴ: "C", quantum: 0.1, marking: 3.3
-    @net = nç.new
-    [@p1, @p2, @p3].each { |p| @net.include_place! p }
-    @p_not_included = pç.new ɴ: "X", marking: 0
+    @w = YPetri::World.new
   end
 
-  describe "net of 3 places and no transitions" do
-    before do
-      @p1.m = 1.1
-      @p2.m = 2.2
-      @p3.m = 3.3
-    end
-
-    it "should expose its elements" do
-      assert_equal [@p1, @p2, @p3], @net.places
-      assert_equal [:A, :B, :C], @net.pp
-      assert_equal [], @net.transitions
-    end
+  it "should initialize" do
+    net = @w.Net.new
+    net.places.must_equal []
+    net.transitions.must_equal []
+    net.pp.must_equal []
+    net.tt.must_equal []
+  end
 
-    it "should expose transition groups" do
-      assert_equal [], @net.transitions_with_rate
-      assert_equal [], @net.rateless_transitions
-      assert_equal [], @net.transitions_without_rate
-      assert_equal [], @net.stoichiometric_transitions
-      assert_equal [], @net.nonstoichiometric_transitions
+  describe "element access" do
+    before do
+      @net = @w.Net.new
     end
 
-    it "should tell its qualities" do
-      assert_equal true, @net.functional?
-      assert_equal true, @net.timed?
-      assert @net.include?( @p1 ) && !@net.include?( YPetri::Place.new )
+    it "should work" do
+      p = @w.Place.new name: "A", quantum: 0.1, marking: 1.1
+      @net.includes_place?( p ).must_equal false
+      @net.include_place p
+      @net.places.must_equal [ p ]
+      @net.place( :A ).must_equal p
+      @net.places( [] ).must_equal []
+      @net.places( [:A] ).must_equal [ p ]
     end
+  end
 
-    it "should have 'standard equipment' methods" do
-      assert @net == @net.dup
-      assert @net.inspect.start_with? "#<Net:"
-      assert @net.include?( @p1 )
-      assert ! @net.include?( @p_not_included )
-      begin
-        @net.exclude_place! @p_not_included
-        @net.include_transition! YPetri::Transition.new( s: { @p_not_included => -1 } )
-        flunk "Attempt to include illegal transition fails to raise"
-      rescue; end
+  describe "world with 3 places" do
+    before do
+      @p1 = @w.Place.new name: "A", quantum: 0.1, marking: 1.1
+      @p2 = @w.Place.new name: "B", quantum: 0.1, marking: 2.2
+      @p3 = @w.Place.new name: "C", quantum: 0.1, marking: 3.3
+      @p4 = @w.Place.new name: "X", marking: 0
     end
 
-    describe "plus 1 stoichio. transition with rate" do
+    describe "net of 3 places and no transitions" do
       before do
-        @t1 = @tç.new!( ɴ: "T1",
-                        s: { @p1 => 1, @p2 => -1, @p3 => -1 },
-                        rate: 0.01 )
-        @net.include_transition! @t1
+        # @p1.m = 1.1
+        # @p2.m = 2.2
+        # @p3.m = 3.3
+        @net = @w.Net.of @p1, @p2, @p3
       end
 
       it "should expose its elements" do
-        assert_equal [@t1], @net.transitions
-        assert_equal [:T1], @net.tt
+        assert_equal [@p1, @p2, @p3], @net.places
+        assert_equal [:A, :B, :C], @net.pn
+        assert_equal [], @net.transitions
       end
 
       it "should expose transition groups" do
-        assert_equal true, @t1.has_rate?
-        assert_equal [@t1], @net.transitions_with_rate
-        assert_equal [], @net.rateless_transitions
-        assert_equal [@t1], @net.stoichiometric_transitions
-        assert_equal [], @net.nonstoichiometric_transitions
+        assert_equal [], @net.S_transitions
+        assert_equal [], @net.s_transitions
       end
 
       it "should tell its qualities" do
         assert_equal true, @net.functional?
-        assert_equal true, @net.timed?
-        assert @net.include?( @t1 )
-      end
-
-      it "should have #place & #transition for safe access to the said elements" do
-        @net.send( :place, @p1 ).must_equal @p1
-        @net.send( :transition, @t1 ).must_equal @t1
+        assert_equal false, @net.timed?
+        assert @net.include?( @p1 ) && !@net.include?( YPetri::Place.new )
       end
 
-      it "has #new_simulation & #new_timed_simulation constructors" do
-        @net.must_respond_to :new_simulation
-        @net.must_respond_to :new_timed_simulation
+      it "should have 'standard equipment' methods" do
+        assert @net == @net.dup
+        assert @net.inspect.start_with? "#<Net:"
+        assert @net.include?( @p1 )
+        assert ! @net.include?( @p_not_included )
+        begin
+          @net.exclude_place! @p_not_included
+          @net.include_transition! YPetri::Transition.new( s: { @p_not_included => -1 } )
+          flunk "Attempt to include illegal transition fails to raise"
+        rescue; end
       end
 
-      it "should have other methods" do
-        assert_equal [1.1, 2.2, 3.3], [@p1, @p2, @p3].map( &:marking ).map{ |n| n.round 6 }
-        assert_equal 2.2 * 3.3 * 0.01, @t1.rate_closure.call( @p2.marking, @p3.marking )
-        assert_equal [ @p2, @p3 ], @t1.domain
-        @t1.fire! 1
-        assert_equal [1.1726, 2.1274, 3.2274], [@p1, @p2, @p3].map( &:marking ).map{ |n| n.round 6 }
-      end
-
-      describe "plus 1 more nameless timeless functionless transition" do
+      describe "plus 1 stoichio. transition with rate" do
         before do
-          @t2 = @tç.new s: { @p2 => -1, @p3 => 1 }
-          @net.include_transition! @t2
+          @t1 = @w.Transition.avid( ɴ: "T1",
+                                    s: { @p1 => 1, @p2 => -1, @p3 => -1 },
+                                    rate: 0.01 )
+          @net.include_transition @t1
         end
 
         it "should expose its elements" do
-          assert_equal [@t1, @t2], @net.transitions
-          assert_equal [:T1, nil], @net.tt
-          @net.tap{ |n| n.exclude_transition! @t1 }.exclude_transition! @t2
-          @net.tap{ |n| n.exclude_place! @p3 }.pp.must_equal [:A, :B]
+          assert_equal [ @t1 ], @net.transitions
+          assert_equal [ :T1 ], @net.tn
+          @net.transition( :T1 ).must_equal @t1
+          @net.transitions( [] ).must_equal []
+          @net.transitions( [ :T1 ] ).must_equal [ @t1 ]
+          @net.element( :T1 ).must_equal @t1
+          @net.elements( [] ).must_equal []
+          @net.elements( [ :T1 ] ).must_equal [ @t1 ]
+          @net.elements( [ :A, :T1 ] ).must_equal [ @p1, @t1 ]
         end
 
         it "should expose transition groups" do
-          assert_equal [], @net.timeless_nonstoichiometric_transitions
-          assert_equal [], @net.timeless_nonstoichiometric_tt
-          assert_equal [@t2], @net.timeless_stoichiometric_transitions
-          assert_equal [nil], @net.timeless_stoichiometric_tt
-          assert_equal [], @net.timed_nonstoichiometric_transitions_without_rate
-          assert_equal [], @net.timed_rateless_nonstoichiometric_transitions
-          assert_equal [], @net.timed_nonstoichiometric_tt_without_rate
-          assert_equal [], @net.timed_rateless_nonstoichiometric_tt
-          assert_equal [], @net.timed_nonstoichiometric_transitions_without_rate
-          assert_equal [], @net.timed_rateless_nonstoichiometric_transitions
-          assert_equal [], @net.timed_nonstoichiometric_tt_without_rate
-          assert_equal [], @net.timed_rateless_nonstoichiometric_tt
-          assert_equal [], @net.nonstoichiometric_transitions_with_rate
-          assert_equal [], @net.nonstoichiometric_tt_with_rate
-          assert_equal [@t1], @net.stoichiometric_transitions_with_rate
-          assert_equal [:T1], @net.stoichiometric_tt_with_rate
-          assert_equal [], @net.assignment_transitions
-          assert_equal [], @net.assignment_tt
-          assert_equal [@t1, @t2], @net.stoichiometric_transitions
-          assert_equal [:T1, nil], @net.stoichiometric_tt
-          assert_equal [], @net.nonstoichiometric_transitions
-          assert_equal [], @net.nonstoichiometric_tt
-          assert_equal [@t1], @net.timed_transitions
-          assert_equal [:T1], @net.timed_tt
-          assert_equal [@t2], @net.timeless_transitions
-          assert_equal [nil], @net.timeless_tt
-          assert_equal [@t1], @net.transitions_with_rate
-          assert_equal [:T1], @net.tt_with_rate
-          assert_equal [@t2], @net.rateless_transitions
-          assert_equal [nil], @net.rateless_tt
+          assert_equal [@t1], @net.S_transitions
+          assert_equal [], @net.s_transitions
         end
 
         it "should tell its qualities" do
-          assert_equal false, @net.functional?
-          assert_equal false, @net.timed?
-          @net.exclude_transition! @t2
           assert_equal true, @net.functional?
           assert_equal true, @net.timed?
+          assert @net.include?( @t1 )
+        end
+
+        it "should have #place & #transition for safe access to them" do
+          @net.send( :place, @p1 ).must_equal @p1
+          @net.send( :transition, @t1 ).must_equal @t1
+          @net.send( :element, @p1 ).must_equal @p1
+        end
+
+        it "has #new_simulation & #new_timed_simulation constructors" do
+          @net.must_respond_to :simulation
+        end
+
+        it "should have other methods" do
+          assert_equal [1.1, 2.2, 3.3], [@p1, @p2, @p3].map( &:marking ).map{ |n| n.round 6 }
+          assert_equal 2.2 * 3.3 * 0.01, @t1.rate_closure.call( @p2.marking, @p3.marking )
+          assert_equal [ @p2, @p3 ], @t1.domain
+          @t1.fire! 1
+          assert_equal [1.1726, 2.1274, 3.2274], [@p1, @p2, @p3].map( &:marking ).map{ |n| n.round 6 }
+        end
+
+        describe "plus 1 more nameless timeless functionless transition" do
+          before do
+            @t2 = @w.Transition.new s: { @p2 => -1, @p3 => 1 }
+            @net.include_transition @t2
+          end
+
+          it "should expose its elements" do
+            assert_equal [@t1, @t2], @net.transitions
+            assert_equal [:T1, nil], @net.tn
+            @net.tap{ |n| n.exclude_transition @t1 }.exclude_transition @t2
+            @net.tap{ |n| n.exclude_place @p3 }.pn.must_equal [:A, :B]
+          end
+
+          it "should expose transition groups" do
+            assert_equal [], @net.ts_transitions
+            assert_equal [], @net.nts
+            assert_equal [@t2], @net.tS_transitions
+            assert_equal [nil], @net.ntS
+            assert_equal [@t1], @net.TS_transitions
+            assert_equal [:T1], @net.nTS
+            assert_equal [], @net.A_transitions
+            assert_equal [], @net.nA
+            assert_equal [@t1, @t2], @net.S_transitions
+            assert_equal [:T1, nil], @net.nS
+            assert_equal [], @net.s_transitions
+            assert_equal [], @net.ns
+            assert_equal [@t1], @net.T_transitions
+            assert_equal [:T1], @net.nT
+            assert_equal [@t2], @net.t_transitions
+            assert_equal [nil], @net.nt
+          end
+
+          it "should tell its qualities" do
+            assert_equal false, @net.functional?
+            assert_equal true, @net.timed?
+            @net.exclude_transition @t2
+            assert_equal true, @net.functional?
+            assert_equal true, @net.timed?
+          end
         end
       end
     end

data/test/place_test.rb

@@ -10,7 +10,7 @@ require_relative '../lib/y_petri'     # tested component itself
 describe YPetri::Place do
   before do
     @pç = pç = Class.new YPetri::Place
-    @p = pç.new! default_marking: 3.2,
+    @p = pç.avid default_marking: 3.2,
                  marking: 1.1,
                  quantum: 0.1,
                  name: "P1"