y_petri 1.0.0

data/lib/y_petri/version.rb

@@ -0,0 +1,3 @@
+module YPetri
+  VERSION = "1.0.0"
+end

data/lib/y_petri/workspace/instance_methods.rb

@@ -0,0 +1,254 @@
+# -*- coding: utf-8 -*-
+
+module YPetri::Workspace::InstanceMethods
+  # Readers for @Place, @Transition, @Net instance variables, which should
+  # contain said classes, or their instance-specific subclasses.
+
+  # Place class or parametrized subclass.
+  # 
+  attr_reader :Place
+
+  # Transition class or parametrized subclass.
+  # 
+  attr_reader :Transition
+
+  # Net class or parametrized subclass.
+  # 
+  attr_reader :Net
+
+  # Collections of clamps, initial marking vectors, and simulation settings.
+  # 
+  attr_reader :clamp_collections,
+              :initial_marking_collections,
+              :simulation_settings_collections
+
+  # Instance initialization.
+  # 
+  def initialize
+    set_up_Top_net # Sets up :Top net encompassing all places and transitions.
+
+    @simulations = {} # { simulation => its settings }
+    @clamp_collections = { Base: {} } # { collection name => clamp hash }
+    @initial_marking_collections = { Base: {} } # { collection name => im hash }
+    @simulation_settings_collections = # { collection name => ss hash }
+      { Base: YPetri::DEFAULT_SIMULATION_SETTINGS.call }
+  end
+
+  # Returns a place instance identified by the argument.
+  # 
+  def place which; Place().instance which end
+
+  # Returns a transition instance identified by the argument.
+  # 
+  def transition which; Transition().instance which end
+
+  # Returns a net instance identified by the argument.
+  # 
+  def net which; Net().instance which end
+
+  # Returns the name of a place identified by the argument.
+  # 
+  def p which; place( which ).name end
+
+  # Returns the name of a transition identified by the argument.
+  # 
+  def t which; transition( which ).name end
+
+  # Returns the name of a net identified by the argument.
+  # 
+  def n which; net( which ).name end
+
+  # Place instances.
+  # 
+  def places; Place().instances end
+
+  # Transition instances.
+  # 
+  def transitions; Transition().instances end
+
+  # Net instances.
+  # 
+  def nets; Net().instances end
+
+  # Hash of simulation instances and their settings.
+  # 
+  def simulations; @simulations end
+
+  # Place names.
+  # 
+  def pp; places.map &:name end
+
+  # Transition names.
+  # 
+  def tt; transitions.map &:name end
+
+  # Net names.
+  # 
+  def nn; nets.map &:name end
+
+  # Clamp collection names.
+  # 
+  def clamp_collection_names; @clamp_collections.keys end
+  alias cc_names clamp_collection_names
+
+  # Initial marking collection names.
+  # 
+  def initial_marking_collection_names; @initial_marking_collections.keys end
+  alias imc_names initial_marking_collection_names
+
+  # Simulation settings collection names.
+  # 
+  def simulation_settings_collection_names
+    @simulation_settings_collections.keys
+  end
+  alias ssc_names simulation_settings_collection_names
+
+  # Clamp collection identified by the argument.
+  # 
+  def clamp_collection name=:Base
+    @clamp_collections[name]
+  end
+  alias cc clamp_collection
+
+  # Marking collection identified by the argument.
+  # 
+  def initial_marking_collection name=:Base
+    @initial_marking_collections[name]
+  end
+  alias imc initial_marking_collection
+
+  # Simulation settings collection specified by the argument.
+  # 
+  def simulation_settings_collection name=:Base
+    @simulation_settings_collections[name]
+  end
+  alias ssc simulation_settings_collection
+
+  # Creates a new clamp collection. If collection identifier is not given,
+  # resets :Base clamp collection to new values.
+  # 
+  def set_clamp_collection( name=:Base, clamp_hash )
+    @clamp_collections[name] = clamp_hash
+  end
+  alias set_cc set_clamp_collection
+
+  # Creates a new initial marking collection. If collection identifier is not
+  # given, resets :Base initial marking collection to new values.
+  # 
+  def set_initial_marking_collection( name=:Base, initial_marking_hash )
+    @initial_marking_collections[name] = initial_marking_hash
+  end
+  alias set_imc set_initial_marking_collection
+
+  # Creates a new simulation settings collection. If collection identifier is
+  # not given, resets :Base simulation settings collection to new values.
+  # 
+  def set_simulation_settings_collection( name=:Base, sim_set_hash )
+    @simulation_settings_collections[name] = sim_set_hash
+  end
+  alias set_ssc set_simulation_settings_collection
+
+  # Presents a simulation specified by the argument, which must be a hash with
+  # four items: :net, :clamp_collection, :inital_marking_collection and
+  # :simulation_settings_collection.
+  # 
+  def simulation settings={}
+    key = case settings
+          when ~:may_have then # it is a hash or equivalent
+            settings.may_have :net
+            settings.may_have :cc, syn!: :clamp_collection
+            settings.may_have :imc, syn!: :initial_marking_collection
+            settings.may_have :ssc, syn!: :simulation_settings_collection
+            { net:  net( settings[:net] || self.Net::Top ), # the key
+              cc:   settings[:cc]       || :Base,
+              imc:  settings[:imc]      || :Base,
+              ssc:  settings[:ssc]      || :Base }
+          else # use the unprocessed argument itself as the key
+            settings
+          end
+    @simulations[ key ]
+  end
+
+  # Makes a new timed simulation. Named arguments for this method are the same
+  # as for TimedSimulation#new, but in addition, :name can be supplied.
+  # 
+  # To create a simulation, simulation settings collection, initial marking
+  # collection, and clamp collection have to be specified. A <em>place clamp</em>,
+  # is a fixed value, at which the marking is held. Similarly, <em>initial
+  # marking</em> is the marking, which a free place receives at the beginning.
+  # Free places are those, that are not clamped. After initialization, marking
+  # of free places is allowed to change as the transition fire.
+  # 
+  # For example, having places :P1..:P5, clamped :P1, :P2 can be written as eg.:
+  # 
+  # * clamps = { P1: 4, P2: 5 }
+  #
+  # Places :P3, :P4, :P5 are <em>free</em>. Their initial marking has to be
+  # specified, which can be written as eg.:
+  #
+  # * initial_markings = { P3: 1, P4: 2, P5: 3 }
+  #
+  # As for simulation settings, their exact nature depends on the simulation
+  # method. For default Euler method, there are 3 important parameters:
+  #   - <em>step_size</em>,
+  #   - <em>sampling_period</em>,
+  #   - <em>target_time</em>
+  #   
+  # For example, default simulation settings are:
+  #
+  # * 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
+
+    # simulation key
+    key = settings.may_have( :ɴ, syn!: :name ) || # either explicit
+      { net: net_ɪ, cc: cc_id, imc: imc_id, ssc: ssc_id } # or constructed
+
+    # Let's clarify what we got so far.
+    simulation_settings = self.ssc( ssc_id )
+    clamp_hash = self.cc( cc_id )
+    im_hash = self.imc( imc_id )
+
+    # Use places' :default_marking in absence of explicit initial marking.
+    untreated = net_ɪ.places.select do |p|
+      ! clamp_hash.map { |k, _| place k }.include? p and
+      ! im_hash.map { |k, _| place k }.include? p
+    end
+    im_complement = Hash[ untreated.zip( untreated.map &:default_marking ) ]
+
+    # If marking can't be figured, raise nice errors.
+    missing = im_complement.select { |_, v| v.nil? }
+    err = lambda { |array, txt=''|
+      raise TypeError, "Missing clamp and/or initial marking for %s#{txt}!" %
+      Array( array ).map { |i| missing.keys[i] }.join( ', ' )
+    }
+    case missing.size
+    when 0 then im_hash = im_hash.merge im_complement # everything's OK
+    when 1 then err.( 0 )
+    when 2 then err.( [0, 1] )
+    when 3 then err.( [0, 1, 2] )
+    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 ) )
+  end # def new_timed_simulation
+
+  private
+
+  # Creates all-encompassing Net instance named :Top.
+  # 
+  def set_up_Top_net
+    Net().new name: :Top # all-encompassing :Top net
+    # Hook new places to add themselves magically to the :Top net.
+    Place().new_instance_closure { |new_inst| net( :Top ) << new_inst }
+    # Hook new transitions to add themselves magically to the :Top net.
+    Transition().new_instance_closure { |new_inst| net( :Top ) << new_inst }    
+  end
+end # module YPetri::Workspace::InstanceMethods

data/lib/y_petri/workspace/parametrized_subclassing.rb

@@ -0,0 +1,26 @@
+
+module YPetri::Workspace::ParametrizedSubclassing
+  def initialize
+    # Parametrized subclasses of Place, Transition and Net.
+    @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
+        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
+      }
+    }
+
+    super # Parametrized subclassing achieved, proceed ahead normally.
+  end # def initialize
+end # module YPetri::Workspace::ParametrizedSubclassing

data/lib/y_petri/workspace.rb

@@ -0,0 +1,16 @@
+#encoding: utf-8
+
+# Workspace holds places, transitions, nets and other assets needed for
+# simulation (settings, clamps, initial markings etc.). Workspace also
+# provides basic methods for their handling, but these are not too public.
+# YPetri interface is defined by YPetri::Manipulator.
+# 
+class YPetri::Workspace
+  include NameMagic
+
+  require_relative 'workspace/instance_methods'
+  require_relative 'workspace/parametrized_subclassing'
+
+  include self::InstanceMethods
+  prepend self::ParametrizedSubclassing
+end

data/lib/y_petri.rb

@@ -0,0 +1,141 @@
+#encoding: utf-8
+
+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/core_ext/hash'
+require 'y_support/core_ext/array'
+require 'y_support/stdlib_ext/matrix'
+
+require 'sy/abstract_algebra'
+
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/array/extract_options'
+
+require_relative 'y_petri/version'
+require_relative 'y_petri/place'
+require_relative 'y_petri/transition'
+require_relative 'y_petri/net'
+require_relative 'y_petri/simulation'
+require_relative 'y_petri/timed_simulation'
+require_relative 'y_petri/workspace'
+require_relative 'y_petri/manipulator'
+
+# YPetri represents Petri net (PN) formalism.
+#
+# 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.
+#
+# 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").
+#
+# 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.
+# 
+module YPetri
+  DEBUG = false
+
+  DEFAULT_SIMULATION_SETTINGS = lambda do
+    { step_size: 0.02,
+      sampling_period: 2,
+      target_time: 60 }
+  end
+
+  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,
+            :place, :transition,
+            :p, :t,
+            :places, :transitions, :nets,
+            :simulations,
+            :pp, :tt, :nn,
+            :clamp_collections,
+            :inital_marking_collections,
+            :simulation_settings_collections,
+            :clamp_cc, :initial_marking_cc, :simulation_settings_cc,
+            :Place,
+            :Transition,
+            :Net,
+            :net_point_reset,
+            :net_point_to, :net→,
+            :net,
+            :simulation_point_reset,
+            :simulation_point_to,
+            :simulation,
+            :simulation_point_position,
+            :cc_point_reset,
+            :cc_point_to, :cc→,
+            :clamp_collection, :cc,
+            :cc_point_position,
+            :imc_point_reset,
+            :imc_point_to, :imc→,
+            :initial_marking_collection, :imc,
+            :imc_point_position,
+            :ssc_point_reset,
+            :ssc_point_to, :ssc→,
+            :simulation_settings_collection, :ssc,
+            :ssc_point_position,
+            :net_selection,
+            :simulation_selection,
+            :ssc_selection,
+            :cc_selection,
+            :imc_selection,
+            :net_selection_clear,
+            :net_select!,
+            :net_select,
+            :net_unselect,
+            :simulation_selection_clear,
+            :simulation_select!,
+            :simulation_select,
+            :simulation_unselect,
+            :cc_selection_clear,
+            :cc_select!,
+            :cc_select,
+            :cc_unselect,
+            :imc_selection_clear,
+            :imc_select!,
+            :imc_select,
+            :imc_unselect,
+            :ssc_selection_clear,
+            :ssc_select!,
+            :ssc_select,
+            :ssc_unselect,
+            :clamp,
+            :initial_marking, :im,
+            :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,
+            :plot_all,
+            to: :y_petri_manipulator )
+end

data/test/simple_manual_examples.rb

@@ -0,0 +1,28 @@
+#encoding: utf-8
+
+require 'y_petri'
+include YPetri
+require 'sy'
+require 'mathn'
+
+set_step 10
+set_target_time 600
+set_sampling 10
+set_simulation_method :Euler_with_timeless_transitions_firing_after_each_step
+
+A = Place m!: 1
+B = Place m!: 10
+C = Place m!: 0
+
+Transition name: :B_disappearing,
+           s: { B: -1 },
+           action: lambda { |m|  m >= 1 ? 1 : 0 }
+
+Transition name: :C_held_at_half_B,
+           assignment: true,
+           domain: :B,
+           codomain: :C,
+           action: lambda { |x| x / 2 }
+
+run!
+plot_recording