y_petri 2.3.3 → 2.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f61f9be5c8c7a131dac0ef18a01d694d0253b13e
-  data.tar.gz: b91fd8337f027bc13bb1d4594475629e3cd14755
+  metadata.gz: ab4404308e31c4a9a63ab12ddb9bf0e38a398fdb
+  data.tar.gz: cd8d2cc2f6c21c1081d3d6364ccfadf307edaee0
 SHA512:
-  metadata.gz: 710cbd7d5aa16b17d15c9ed45d9a3ddc0b99d0fcd72eb7ce45a25259e7934d86a8a451e35a71c6dfd2d88d90d1947e10fca8e45a1ae4260bb172e81e9850f762
-  data.tar.gz: 585d6dd8b10ece874569d2ada743368eaa7f163f03e002b5b497131e46d02ad2cfab421089b21895e7673db9e53ff263241a9b48684dc98616d8af4919d17506
+  metadata.gz: 9da0176d66c7792f3fc0539577be721ab130507a486b7392ccaed64ccfef0e5ce5a330c6127a9c69a007104c35cda9d876bcf57999cf79d6b9dfe1156ad9c507
+  data.tar.gz: f4fa59e863486eea853560ecd71c76dbf31ab5381e0f670ad93bc2a32018d0f45b3b34364f88ae2fc674a1942b94884f86ba0856b1c9498e956ccedcbbbbe8cb

data/ACKNOWLEDGMENT.txt

@@ -0,0 +1,6 @@
+This document serves to acknowledge the support of Bioinformatics Program,
+Taiwan International Graduate Program, Institute of Computer Science,
+Academia Sinica (128, Academia Road, Sec. 2. Namkang, Taipei, 115), and
+of Bioinformatics Institute, National Yang-Ming University, Taipei,
+Taiwan. Without their support, creation of this package would not be
+possible.

data/README.md

@@ -1,19 +1,15 @@
 # YPetri
 
-`YPetri` is a domain model and a simulator of _YPetri_ nets, a specific kind of
-_Petri_ _nets_ unifying discrete/continous, deterministic/stochastic,
-timed/timeless and stoichiometric/nonstoichiometric dichotomies, thus enabling
-modelling and simulation of dynamic systems of any kind whatsoever.
+`YPetri` is a domain model and a simulator of dynamical systems. It was inspired by the problems from the field of modelling of biochemical pathways, but on purpose, YPetri is not specific to biochemistry. As a matter of separation of concerns, YPetri caters solely to the two main concerns of modelling, model specification and simulation, excelling in the first one. YPetri implements a novel universal Petri net type, that integrating discrete/continous, deterministic/stochastic, timed/timeless and stoichiometric/nonstoichiometric dichotomies commonly seen in extended Petri nets. YPetri allows specification of any kind of dynamical system whatsoever.
 
 ## Usage
 
-`YPetri` provides a _domain_ _specific_ _modeling_ _language_ (DSML), that can
-be loaded by:
+`YPetri` provides a _domain_ _specific_ _language_ (DSL) that can be loaded by:
 ```ruby
   require 'y_petri'
   include YPetri
 ```
-Now, one can create places:
+(As a matter of terminology, DSLs used in modelling are sometimes termed _domain_ _specific_ _modelling_ _languages_ (DSMLs). This term is popular especially in engineering.) Petri net places can now be created:
 ```ruby
   A = Place()
   B = Place()

data/lib/y_petri/net/data_set.rb

@@ -1,29 +1,33 @@
 # encoding: utf-8
 
-# +DataSet+ is a collection of labeled state records. It is a subclass of +Hash+
-# class, whose keys are known as _events_, and values are data points (arrays)
-# that correspond to saved records (+YPetri::Net::State::Features::Record+) under
-# a given feature set (+YPetri::Net::State::Features+). +DataSet+ class is
-# intended to be parametrized with a specific feature set. Apart from the methods
-# inherited from +Hash+, +YPetri::Net::DataSet+ can load a record at a given
-# event (+#record+ method), reconstruct a simulation at a given event
+# +YPetri::Net::DataSet+ is a collection of labeled state records. It is
+# a subclass of +Hash+. +DataSet+ keys are known as _events_, and values
+# are data points. Each of these data points is an array that can be used
+# to reconstruct a record, (an object of
+# +YPetri::Net::State::Features::Record+ class). Each record records
+# a specific feature set (of +YPetri::Net::State::Features+ class). +DataSet+
+# class is intended to be parametrized with such specific feature set, which
+# indicates the meaning of its data points.
+# 
+# Apart from methods inherited from +Hash+, +DataSet+ can load a record at
+# a given event (+#record+ method), reconstruct a simulation at a given event
 # (+#reconstruct+ method), return columns corresponding to features (+#series+
 # method) and perform feature selection (+#marking+, +#firing+, +#flux+,
-# +#gradient+, +#delta+, +#assignment+, and +#reduced_features+ for mixed feature
-# sets). Apart from standard inspection methods, +DataSet+ has methods +#print+
-# and +#plot+ for visual presentation. Also, +DataSet+ has methods specially
-# geared towards records of timed simulations, whose events are points in time.
-# Method +#interpolate+ uses linear interpolation to find the approximate state
-# of the system at some exact time using linear interpolation between the nearest
-# earlier and later data points (which can be accessed respectively by +#floor+
-# and +#ceiling+ methods). Interpolation is used for resampling the set
-# (+#resample+ method).
+# +#gradient+, +#delta+, +#assignment+, and +#reduced_features+ for mixed
+# feature sets). Apart from standard inspection methods, +DataSet+ has methods
+# +#print+ and +#plot+ for visual presentation. Also, +DataSet+ has methods
+# specially geared towards records of timed simulations, whose events are points
+# in time. Method +#interpolate+ uses linear interpolation to find the
+# approximate state of the system at some exact time using linear interpolation
+# between the nearest earlier and later data points (which can be accessed
+# respectively by +#floor+ and +#ceiling+ methods). Interpolation is available
+# to the user, and is also used by +DataSet#resample+ method for resampling
+# the dataset.
 #
 # Finally, it is possible that especially professional statisticians have
 # written, or are planning to write, a +DataSet+ class better than this one.
 # If I discover a good +DataSet+ class in the future, I would like to inherit
-# from it or otherwise integrate with it for the purposes of
-# +YPetri::Net::DataSet+.
+# from it or otherwise integrate with it for the purposes of +DataSet+.
 # 
 class YPetri::Net::DataSet < Hash
   class << self
@@ -50,7 +54,7 @@ class YPetri::Net::DataSet < Hash
            :net,
            to: "self.class"
 
-  attr_reader :type, # more like event_type, idea not matured yet
+  attr_reader :type,     # TODO: More like event_type, idea not matured yet.
               :settings
 
   # Type of the dataset.
@@ -307,6 +311,7 @@ class YPetri::Net::DataSet < Hash
     Delta( net.places, transitions: transitions, **named_args )
   end
 
+  # 
   def delta_timed *ordered_args, **named_args
     delta *ordered_args, transitions: net.T_transitions, **named_args
   end
@@ -350,7 +355,6 @@ class YPetri::Net::DataSet < Hash
   # this dataset are meant to be plotted.
   # 
   def plot( nodes=nil, except: [], **named_args )
-    puts "Hello from plot!"
     nn = named_args
     time = nn.may_have :time, syn!: :time_range
     events = events()

data/lib/y_petri/net/state/features/record.rb

@@ -139,7 +139,7 @@ class YPetri::Net::State::Features::Record < Array
   # net.
   # 
   def Gradient array, transitions: nil
-    array.map { |id|
+   array.map { |id|
       fetch( net.State.Feature.Gradient id, transitions: transitions )
     }
   end

data/lib/y_petri/net/state/features.rb

@@ -1,6 +1,18 @@
 # encoding: utf-8
 
-# A set of state features.
+# A feature set. In other words, a set of state features, such as marking,
+# flux etc.
+#
+# marking:: Applicable to all places, all places have marking.
+# firing:: Applicable to all stoichiometric transitions, but delta time has
+#          to be known for timed transitions.
+# flux:: Applicable to timed stochiometric transitions only.
+# delta:: Expresses change to a chosen set of places caused by firing of a
+#         chosen set of transitions. Requires delta time to be provided if
+#         there are timed transitions in the set.
+# gradient:: Expresses gradient of change of a chosen set of places caused by
+#            firing of a chosen set of transitions. Only applicable to timed
+#            transitions.
 # 
 class YPetri::Net::State::Features < Array
   require_relative 'features/record'

data/lib/y_petri/net/state.rb

@@ -20,7 +20,7 @@ class YPetri::Net::State < Array
     end
 
     # Returns the feature identified by the argument.
-    #
+    # 
     def Feature arg=nil, **named_args
       case arg
       when Feature() then arg
@@ -62,9 +62,11 @@ class YPetri::Net::State < Array
 
   delegate :net,
            :Feature,             # Note that as syntactic salt, specific methods
-           :Features,            # #marking, #firing, #gradient, #flux etc. are
-           :features,            # not delegated to self.class.
+           :Features,            # #firing, #gradient, #flux etc. are not
+           :features,            # delegated to self.class.
            to: "self.class"
+  # FIXME: #features method above actually doesn't work in practice, self.class
+  # doesn't have it.
 
   # Given a set of clamped places, this method outputs a +Record+ instance
   # containing the marking of the free places (complementary to the supplied
@@ -77,8 +79,8 @@ class YPetri::Net::State < Array
                   else
                     places - places( clamped_places )
                   end
-    features( marking: free_places ).Record.load markings( free_places ) 
-  end
+    features( marking: free_places ).Record.load markings( free_places )
+  end # FIXME: I find it not working atm.
 
   # Marking of a single given place in this state.
   # 

data/lib/y_petri/net/visualization.rb

@@ -18,12 +18,12 @@ module YPetri::Net::Visualization
     transition_nodes = transitions.map.with_object Hash.new do |tr, ꜧ|
       ꜧ[tr] = γ.add_nodes tr.name.to_s,
                           shape: 'box',
-                          fillcolor: if tr.assignment? then 'yellow'
-                                     elsif tr.type == :TS then 'lightcyan'
-                                     else 'ghostwhite' end,
-                          color: if tr.assignment? then 'goldenrod'
-                                 elsif tr.type == :TS then 'cyan'
-                                 else 'grey' end,
+                          fillcolor: ( if tr.assignment? then 'yellow'
+                                       elsif tr.type == :TS then 'lightcyan'
+                                       else 'ghostwhite' end ),
+                          color: ( if tr.assignment? then 'goldenrod'
+                                   elsif tr.type == :TS then 'cyan'
+                                   else 'grey' end ),
                           style: 'filled'
     end
     # Add Petri net arcs.

data/lib/y_petri/net.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# coding: utf-8
 
 require_relative 'net/node_access'
 require_relative 'net/visualization'
@@ -13,16 +13,6 @@ require_relative 'net/state'
 # neighbors of nodes (places or transitions).
 # 
 class YPetri::Net
-  # ===========================================================================
-  # !!! TODO !!!
-  #
-  # Refactoring plans for Net class
-  #
-  # Make it a subclass of Module class, so places and transitions can simply
-  # be defined as its constants.
-  #
-  # ===========================================================================
-
   ★ NameMagic                        # ★ means include
   ★ NodeAccess
   ★ Visualization

data/lib/y_petri/place/guarded.rb

@@ -5,21 +5,21 @@
 module YPetri::Place::Guarded
   # Expects a guard assertion in natural language, and a guard block. Guard
   # block is a unary block that validates marking. A validation fails when:
-  #
+  # 
   # 1. The block returns _false_.
   # 2. The block raises +YPetri::GuardError+.
-  #
+  # 
   # In all other cases, including when the block returns _nil_ (beware!),
   # the marking is considered valid! Inside the block, +#fail+ keyword is
   # redefined so that it can (and must) be called without arguments, and it
   # raises an appropriately worded +GuardError+. (Other exceptions can still
   # be raised using +#raise+ keyword.) Practical example:
-  #
+  # 
   #   guard "should be a number" do |m| fail unless m.is_a? Numeric end
-  #
+  # 
   # Then <code>guard! :foobar</code> raises +GuardError+ with a message "Marking
   # foobar:Symbol should be a number!"
-  #
+  # 
   # Finally, this method is overloaded in such way, that if no block is
   # given to it, it acts as an alias of +#common_guard_closure+ method.
   # 

data/lib/y_petri/simulation/dependency.rb

@@ -1,9 +1,10 @@
 # encoding: utf-8
 
-# Place / transition collection mixin for parametrized classes of
-# YPetri::Simulation. Expects the includer to provide +#simulation+
-# method returning current +Simulation+ instance.
-#
+# Mixin providing collections of places / transitions to classes parametrized
+# by an instance of YPetri::Simulation. Expects the includer classes to provide
+# +#simulation+ method returning the +Simulation+ instance with which they are
+# parametrized.
+# 
 class YPetri::Simulation
   module Dependency
     delegate :Place,
@@ -25,17 +26,18 @@ class YPetri::Simulation
              :m_vector,
              :recorder,
              to: :simulation
-
-    # Delegates to the protected (and private) methods of simulation.
+    
+    # Delegates supplied method symbols to the protected (and private) methods
+    # of the simulation.
     # 
-    def self.delegate_to_simulation! *symbols
-      symbols.each do |sym|
+    def self.delegate_to_simulation! *method_symbols
+      method_symbols.each do |symbol|
         module_exec do
-          define_method sym do |*aa, &b| simulation.send sym, *aa, &b end
+          define_method symbol do |*aa, &b| simulation.send symbol, *aa, &b end
         end
       end
     end
-
+    
     # Necessary to overcoming the protected character of the listed methods.
     # 
     [ :node,

data/lib/y_petri/simulation/matrix.rb

@@ -2,9 +2,11 @@
 
 require 'matrix'
 
-# Patches the Matrix class with methods that generate code for direct vector
-# access.
-#
+# Patches built-in Matrix class with methods that generate code for direct
+# vector access. This is used in simulation. It is imaginable and desirable
+# that this way of simulation be refactored, and also, a faster way of
+# simulation provided using NMatrix class.
+# 
 class Matrix
   class << self
     # Builds a code string for accessing the vector values at given indices.
@@ -13,7 +15,7 @@ class Matrix
                                   indices: (fail ArgumentError, "No indices!")
       indices.map { |i| "#{vector}[#{i}, 0]" }.join( ", " )
     end
-  
+    
     # Builds a code string for assigning to a vector at given indices.
     # 
     def column_vector_assignment_code vector: (fail ArgumentError, "No vector!"),
@@ -24,7 +26,7 @@ class Matrix
       end
       code_lines.compact.join( "\n" ) << "\n"
     end
-
+    
     # Builds a code string for incrementing a vector at given indices. Source is
     # a vector.
     # 
@@ -37,7 +39,7 @@ class Matrix
       end
       code_lines.compact.join( "\n" ) << "\n"
     end
-
+    
     # Builds a code string for incrementing a vector at given indices. Source is
     # an array.
     # 
@@ -51,7 +53,7 @@ class Matrix
       code_lines.compact.join( "\n" ) << "\n"
     end
   end
-
+  
   # Builds a closure for incrementing a column at given indices.
   # 
   def increment_at_indices_closure indices: (fail ArgumentError, "No indices!")

data/lib/y_petri/simulation/node_representation.rb

@@ -1,6 +1,11 @@
 # encoding: utf-8
 
-# Representation of a YPetri::Place inside a YPetri::Simulation instance.
+# Representation of a +YPetri+ node inside a +YPetri::Simulation+ instance.
+# An instance of +YPetri::Simulation+ does is constructed based on an instance
+# of +YPetri::Net+, but not directly work with Petri net nodes (that is, it
+# does not work with instances of +YPetri::Place+ or +YPetri::Transition+).
+# Instead, it creates its own internal representations of the nodes of the
+# Petri net it is constructed from -- instances of NodeRepresentation.
 #
 class YPetri::Simulation::NodeRepresentation
   ★ NameMagic
@@ -10,7 +15,7 @@ class YPetri::Simulation::NodeRepresentation
 
   delegate :simulation, to: "self.class"
 
-  # Expect a single YPetri place as an argument.
+  # Expect a single YPetri node (place or transition) as an argument.
   # 
   def initialize net_node_id
     @source = net.node( net_node_id )

data/lib/y_petri/simulation/nodes.rb

@@ -1,27 +1,27 @@
 # encoding: utf-8
 
 class YPetri::Simulation
-  # An array of simulation owned places and/or transitions.
+  # An array of simulation-owned places and/or transitions.
   # 
   class Nodes < Array
     ★ Dependency
-
+    
     class << self
       # New collection constructor
-      #
+      # 
       def load collection
         new.tap { |inst| inst.load collection }
       end
     end
-
+    
     delegate :simulation, to: "self.class"
-
+    
     # Loads nodes to this collection.
-    #
+    # 
     def load nodes
       nodes.each{ |node| push node }
     end
-
+    
     # Creates a subset of this collection (of the same class).
     # 
     def subset nodes=nil, &block
@@ -37,7 +37,7 @@ class YPetri::Simulation
         self.class.load( nn )
       end
     end
-
+    
     # Returns an array of the node sources (nodes in the underlying net).
     # 
     def sources

data/lib/y_petri/simulation/places/access.rb

@@ -89,7 +89,9 @@ class YPetri::Simulation::Places
     # that even without an argument, it does not fail, but returns the @Places
     # parametrized subclass itself.
     # 
-    def Places( array )
+    def Places( array ) # TODO: Understand why this method does not behave
+                        # as protected in real Simulation instances, while
+                        # places method just above does.
       # Kernel.p array
       Places().load array.map &method( :place )
     end

data/lib/y_petri/simulation/places.rb

@@ -3,7 +3,6 @@
 # Place collection for YPetri::Simulation.
 #
 class YPetri::Simulation::Places < YPetri::Simulation::Nodes
-
   require_relative 'places/types'
   require_relative 'places/free'
   require_relative 'places/clamped'

data/lib/y_petri/transition/construction_convenience.rb

@@ -168,7 +168,7 @@ module YPetri::Transition::ConstructionConvenience
   def __upstream_for_A__( **nn )
     dom = domain
     funct = true
-    λ = nn[:assignment].aT_is_a Proc, "supplied :assigmnent argument"
+    λ = nn[:assignment].aT_is_a Proc, "supplied assignment argument"
     if dom == :missing then
       dom = λ.arity == 0 ? [] : codomain
     else

data/lib/y_petri/version.rb

@@ -1,4 +1,4 @@
 module YPetri
-  VERSION = "2.3.3"
+  VERSION = "2.3.4"
   DEBUG = false
 end

data/lib/y_petri.rb

@@ -35,27 +35,26 @@ require_relative 'y_petri/core'
 require_relative 'y_petri/agent'
 require_relative 'y_petri/dsl'
 
-# YPetri represents Petri net (PN) formalisms.
+# YPetri is a domain model and a domain-specific language (DSL) for modelling of
+# dynamical systems. YPetri module contains a collection of assets for Petri
+# net-based model specification and its simulation.
 #
-# 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.
+# A Petri net (PN) is a bipartite graph with two kinds of nodes: places and
+# transitions. Places are visualised as circles, transitions as rectangles. Arcs
+# connecting places and transitions are visualised as lines, but these are not
+# considered first class citizens in YPetri abstraction.
 #
 # 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.
+# marking by adding / removing tokens as dictated by the prescription of their
+# operation. This can be done by attaching a function to the transition. Such
+# transitions are called functional transitions in YPetri. Borrowing more from
+# the functional terminology, YPetri defines keywords domain an codomain for
+# a PN transition in a way similar to the domain and codomain of a function.
 #
-# 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.
+# YPetri unifies discrete and stochastic modelling of timed transitions at the
+# level of model specification in line with the present day unifying Petri net
+# frameworks. YPetri also integrates other dichotomies: timed / timeless and
+# stoichiometric / nonstoichiometric.
 # 
 module YPetri
   class << self

data/test/acceptance/simulation_test.rb

@@ -4,7 +4,7 @@
 require 'minitest/autorun'
 require_relative '../../lib/y_petri'     # tested component itself
 # require 'y_petri'
-# require 'sy'
+require 'sy'
 
 describe "Simplified dTTP pathway used for demo with Dr. Chang" do
   before do
@@ -42,74 +42,80 @@ describe "Simplified dTTP pathway used for demo with Dr. Chang" do
     @m.clamp Deoxycytidine: 0.5, DeoxyCTP: 1.0, DeoxyGMP: 1.0
     @m.clamp Thymidine: 0.5
     @m.clamp UMP_UDP_pool: 2737.0
+
     # Functions
     Vmax_per_minute_per_enzyme_molecule =
-      lambda { |enzyme_specific_activity_in_micromol_per_minute_per_mg,
-                enzyme_molecular_mass_in_kDa|
-                  enzyme_specific_activity_in_micromol_per_minute_per_mg *
-                    enzyme_molecular_mass_in_kDa }
+      -> specific_activity_µmol_per_min_per_mg, mol_mass_in_kDa {
+        specific_activity_µmol_per_min_per_mg * mol_mass_in_kDa
+    }
+
     Vmax_per_minute =
-      lambda { |specific_activity, kDa, enzyme_molecules_per_cell|
-               Vmax_per_minute_per_enzyme_molecule.( specific_activity, kDa ) *
-                 enzyme_molecules_per_cell }
+      -> specific_activity, kDa, enzyme_molecules_per_cell {
+        Vmax_per_minute_per_enzyme_molecule.( specific_activity, kDa ) *
+        enzyme_molecules_per_cell
+    }
+
     Vmax_per_second =
-      lambda { |specific_activity, kDa, enzyme_molecules_per_cell|
-               Vmax_per_minute.( specific_activity,
-                                 kDa,
-                                 enzyme_molecules_per_cell ) / 60 }
+      -> specific_activity, kDa, enzyme_molecules_per_cell {
+        Vmax_per_minute.( specific_activity, kDa, enzyme_molecules_per_cell ) / 60
+    }
+
     Km_reduced =
-      lambda { |km, ki_hash={}|
-               ki_hash.map { |concentration, ci_Ki|
-                             concentration / ci_Ki
-                           }.reduce( 1, :+ ) * km }
+      -> km, ki_hash=Hash.new {
+        ki_hash.map { |conc, ci_Ki| conc / ci_Ki }.reduce( 1, :+ ) * km
+    }
+
     Occupancy =
-      lambda { |concentration, reactant_Km, compet_inh_w_Ki_hash={}|
-               concentration / ( concentration +
-                                 Km_reduced.( reactant_Km,
-                                              compet_inh_w_Ki_hash ) ) }
+      -> conc, reactant_Km, compet_inh_w_Ki_hash=Hash.new {
+        conc / ( conc + Km_reduced.( reactant_Km, compet_inh_w_Ki_hash ) )
+    }
+
     MM_with_inh_micromolars_per_second =
-      lambda { |reactant_concentration,
-                enzyme_specific_activity,
-                enzyme_mass_in_kDa,
-                enzyme_molecules_per_cell,
-                reactant_Km,
-                competitive_inh_w_Ki_hash={}|
-                Vmax_per_second.( enzyme_specific_activity,
-                                  enzyme_mass_in_kDa,
-                                  enzyme_molecules_per_cell ) *
-                  Occupancy.( reactant_concentration,
+      -> reactant_conc, enz_spec_activity, enz_mass_in_kDa,
+         enz_molecules_per_cell, reactant_Km, compet_inh_w_Ki_hash=Hash.new {
+      Vmax_per_second.( enz_spec_activity,
+                        enz_mass_in_kDa,
+                        enz_molecules_per_cell ) *
+                  Occupancy.( reactant_conc,
                               reactant_Km,
-                              competitive_inh_w_Ki_hash ) }
+                              compet_inh_w_Ki_hash )
+    }
+
     MMi = MM_with_inh_micromolars_per_second
     TK1_Thymidine_Km = 5.0
     TYMS_DeoxyUMP_Km = 2.0
     RNR_UDP_Km = 1.0
-    DNA_creation_speed = 3_000_000_000 / ( 12 * 3600 )
+    DNA_creation_speed = 3_000_000_000 / ( 12 * 3600 ) / Pieces_per_micromolar
     TMPK_DeoxyTMP_Km = 12.0
 
     # transitions
     @m.Transition name: :TK1_Thymidine_DeoxyTMP,
-                  domain: [ Thymidine, TK1, DeoxyTDP_DeoxyTTP_pool, DeoxyCTP, Deoxycytidine, AMP, ADP, ATP ],
+                  domain: [ Thymidine, TK1, DeoxyTDP_DeoxyTTP_pool,
+                            DeoxyCTP, Deoxycytidine, AMP, ADP, ATP ],
                   stoichiometry: { Thymidine: -1, DeoxyTMP: 1 },
                   rate: proc { |rc, e, pool1, ci2, ci3, master1, master2, master3|
                                ci1 = pool1 * master3 / ( master2 + master3 )
                                MMi.( rc, TK1_a, TK1_kDa, e, TK1_Thymidine_Km,
                                      ci1 => 13.5, ci2 => 0.8, ci3 => 40.0 ) }
+
     @m.Transition name: :TYMS_DeoxyUMP_DeoxyTMP,
                   domain: [ DeoxyUMP_DeoxyUDP_pool, TYMS, AMP, ADP, ATP ],
                   stoichiometry: { DeoxyUMP_DeoxyUDP_pool: -1, DeoxyTMP: 1 },
                   rate: proc { |pool, e, master1, master2, master3|
                           rc = pool * master2 / ( master1 + master2 )
                           MMi.( rc, TYMS_a, TYMS_kDa, e, TYMS_DeoxyUMP_Km ) }
+
     @m.Transition name: :RNR_UDP_DeoxyUDP,
                   domain: [ UMP_UDP_pool, RNR, DeoxyUMP_DeoxyUDP_pool, AMP, ADP, ATP ],
                   stoichiometry: { UMP_UDP_pool: -1, DeoxyUMP_DeoxyUDP_pool: 1 },
                   rate: proc { |pool, e, master1, master2, master3|
                                rc = pool * master2 / ( master1 + master2 )
                                MMi.( rc, RNR_a, RNR_kDa, e, RNR_UDP_Km ) }
+
     @m.Transition name: :DNA_polymerase_consumption_of_DeoxyTTP,
                   stoichiometry: { DeoxyTDP_DeoxyTTP_pool: -1 },
                   rate: proc { DNA_creation_speed / 4 }
+
     @m.Transition name: :TMPK_DeoxyTMP_DeoxyTDP,
                   domain: [ DeoxyTMP, TMPK, ADP,
                             DeoxyTDP_DeoxyTTP_pool,
@@ -121,6 +127,7 @@ describe "Simplified dTTP pathway used for demo with Dr. Chang" do
                                ci3 = pool * master3 / ( master2 + master3 )
                                MMi.( rc, TMPK_a, TMPK_kDa, e, TMPK_DeoxyTMP_Km,
                                      ci1 => 250.0, ci2 => 30.0, ci3 => 750, ci4 => 117 ) }
+
   end
 
   it "should work" do

data/test/y_petri_test.rb

@@ -1,7 +1,6 @@
 #! /usr/bin/ruby
 #encoding: utf-8
 
-gem 'minitest'
 require 'minitest/autorun'
 require_relative '../lib/y_petri' # tested component itself
 # require 'y_petri'

data/y_petri.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = YPetri::VERSION
   spec.authors       = ["boris"]
   spec.email         = ["\"boris@iis.sinica.edu.tw\""]
-  spec.summary       = %q{Systems modelling and simulation gem, and a domain model of a special kind of Petri nets (YPetri nets) that can be used to model and simulate any kind of dynamic systems.}
-  spec.description   = %q{YPetri is a gem for modelling and simulation of dynamic systems. Wiring diagram of a dynamic system to be modelled is expressed as YPetri net, a specific kind of Petri net that unifies discrete/continous, deterministic/stochastic, timed/timeless and stoichiometric/nonstoichiometric dichotomies, thus enabling modelling and simulation of dynamic systems of any kind whatsoever. Like Petri nets themselves, YPetri was inspired by problems from the domain of chemistry, but its use is not limited to it.}
+  spec.summary       = %q{Systems modelling and simulation gem, and a domain model of a specific type of universal Petri net (YPetri net), which can be used to model any kind of dynamical system whatsoever.}
+  spec.description   = %q{YPetri is a gem for modelling of dynamical systems. It caters solely to the two main concerns of modelling, model specification and simulation, and it excels in the first one. Dynamical systems are described under a Petri net paradigm. YPetri implements a universal Petri net abstraction that integrates discrete/continous, deterministic/stochastic, timed/timeless and stoichiometric/nonstoichiometric dichotomies of the extended Petri nets, and allows efficient specification of any kind of dynamical system. Like Petri nets themselves, YPetri was inspired by problems from the domain of chemistry (biochemical pathway modelling), but it is not specific it. Other gems, YChem and YCell are planned to cater to the concerns specific to chemistry and cell biochemistry. As a part of this effort, an extended version of YPetri is under development. Its name is YNelson, its usage is practically identical to YPetri, but it covers more concerns than just Petri net specification and simulation. Namely, YNelson allows relations among Petri net nodes and parameters to be captured under a zz structure paradigm (which was developed by Ted Nelson) and it also provides higher level of abstraction in Petri net specification by providing commands that create more than one Petri net node per command.}
   spec.homepage      = ""
   spec.license       = "GPLv3"
 

metadata

@@ -1,113 +1,123 @@
 --- !ruby/object:Gem::Specification
 name: y_petri
 version: !ruby/object:Gem::Version
-  version: 2.3.3
+  version: 2.3.4
 platform: ruby
 authors:
 - boris
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-24 00:00:00.000000000 Z
+date: 2014-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: y_support
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: gnuplot
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: ruby-graphviz
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: distribution
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: YPetri is a gem for modelling and simulation of dynamic systems. Wiring
-  diagram of a dynamic system to be modelled is expressed as YPetri net, a specific
-  kind of Petri net that unifies discrete/continous, deterministic/stochastic, timed/timeless
-  and stoichiometric/nonstoichiometric dichotomies, thus enabling modelling and simulation
-  of dynamic systems of any kind whatsoever. Like Petri nets themselves, YPetri was
-  inspired by problems from the domain of chemistry, but its use is not limited to
-  it.
+description: YPetri is a gem for modelling of dynamical systems. It caters solely
+  to the two main concerns of modelling, model specification and simulation, and it
+  excels in the first one. Dynamical systems are described under a Petri net paradigm.
+  YPetri implements a universal Petri net abstraction that integrates discrete/continous,
+  deterministic/stochastic, timed/timeless and stoichiometric/nonstoichiometric dichotomies
+  of the extended Petri nets, and allows efficient specification of any kind of dynamical
+  system. Like Petri nets themselves, YPetri was inspired by problems from the domain
+  of chemistry (biochemical pathway modelling), but it is not specific it. Other gems,
+  YChem and YCell are planned to cater to the concerns specific to chemistry and cell
+  biochemistry. As a part of this effort, an extended version of YPetri is under development.
+  Its name is YNelson, its usage is practically identical to YPetri, but it covers
+  more concerns than just Petri net specification and simulation. Namely, YNelson
+  allows relations among Petri net nodes and parameters to be captured under a zz
+  structure paradigm (which was developed by Ted Nelson) and it also provides higher
+  level of abstraction in Petri net specification by providing commands that create
+  more than one Petri net node per command.
 email:
 - '"boris@iis.sinica.edu.tw"'
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
+- ACKNOWLEDGMENT.txt
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -249,22 +259,22 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Systems modelling and simulation gem, and a domain model of a special kind
-  of Petri nets (YPetri nets) that can be used to model and simulate any kind of dynamic
-  systems.
+summary: Systems modelling and simulation gem, and a domain model of a specific type
+  of universal Petri net (YPetri net), which can be used to model any kind of dynamical
+  system whatsoever.
 test_files:
 - test/acceptance/basic_usage_test.rb
 - test/acceptance/simulation_test.rb