y_petri 2.0.15 → 2.1.3

data/lib/y_petri/net.rb

@@ -1,102 +1,101 @@
 #encoding: utf-8
 
-require_relative 'dependency_injection'
 require_relative 'net/visualization'
-require_relative 'net/selections'
+require_relative 'net/element_access'
+require_relative 'net/state'
 
 # Represents a _Petri net_: A collection of places and transitions. The
 # connector arrows – called _arcs_ in classical Petri net terminology – can be
-# considered a property of transitions. Therefore in +YPetri+, term 'arcs' is
-# mostly used as a synonym  denoting neighboring places / transitions.
+# considered a property of transitions. Therefore in +YPetri::Net+, you won't
+# find arcs as first-class citizens, but only as a synonym denoting nearest
+# neighbors of elements (places or transitions).
 # 
 class YPetri::Net
   include NameMagic
-  include YPetri::DependencyInjection
-  
-  attr_reader :places, :transitions
+  include YPetri::World::Dependency # it is important for the Dependency
+  include ElementAccess             # to be below ElementAccess
 
+  class << self
+    include YPetri::World::Dependency
+
+    # Constructs a net containing a particular set of elements.
+    # 
+    def of *elements
+      new.tap { |inst| elements.each { |e| inst << e } }
+    end
+  end
+
+  delegate :world, to: "self.class"
+
+  # Takes 2 arguments (+:places+ and +:transitions+) and builds a net from them.
+  # 
   def initialize( places: [], transitions: [] )
-    @places, @transitions = places, transitions
+    param_class( { State: State }, with: { net: self } )
+    @places, @transitions = [], []
+    places.each &method( :include_place )
+    transitions.each &method( :include_transition )
+    param_class( { Simulation: YPetri::Simulation },
+                 with: { net: self } )
   end
 
   # Includes a place in the net. Returns _true_ if successful, _false_ if the
   # place is already included in the net.
   # 
-  def include_place! place
-    pl = place( place )
-    return false if @places.include? pl
-    @places << pl
-    return true
+  def include_place id
+    pl = Place().instance( id )
+    return false if includes_place? pl
+    true.tap { @places << pl }
   end
 
   # Includes a transition in the net. Returns _true_ if successful, _false_ if
   # the transition is already included in the net. The arcs of the transition
   # being included may only connect to the places already in the net.
   # 
-  def include_transition! transition;
-    tr = transition( transition )
-    return false if @transitions.include? tr
-    raise TypeError, "Unable to include the transition #{tr} in #{self}: " +
-      "It connects to one or more places outside the net." unless
-      tr.arcs.all? { |pl| include? pl }
-    @transitions << tr
-    return true
+  def include_transition id
+    tr = Transition().instance( id )
+    return false if includes_transition? tr
+    true.tap { @transitions << tr }
   end
 
   # Excludes a place from the net. Returns _true_ if successful, _false_ if the
   # place was not found in the net. A place may not be excluded from the net so
   # long as any transitions in the net connect to it.
   # 
-  def exclude_place! place
-    pl = place( place )
-    raise "Unable to exclude #{pl} from #{self}: One or more transitions" +
-      "depend on it" if transitions.any? { |tr| tr.arcs.include? pl }
-    return true if @places.delete pl
-    return false
+  def exclude_place id
+    pl = Place().instance( id )
+    msg = "Unable to exclude #{pl} from #{self}: Transition(s) depend on it!"
+    fail msg if transitions.any? { |tr| tr.arcs.include? pl }
+    false.tap { return true if @places.delete( pl ) }
   end
 
   # Excludes a transition from the net. Returns _true_ if successful, _false_ if
   # the transition was not found in the net.
   # 
-  def exclude_transition! transition
-    tr = transition( transition )
-    return true if @transitions.delete tr
-    return false
+  def exclude_transition id
+    tr = Transition().instance( id )
+    false.tap { return true if @transitions.delete( tr ) }
   end
 
-  # Includes an object (either place or transition) in the net. Acts by calling
-  # +#include_place!+ or +#include_transition!+, as needed, swallowing errors.
+  # Includes an element in the net.
   # 
-  def << place_or_transition
-    begin
-      include_place! place_or_transition
-    rescue NameError
-      begin
-        include_transition! place_or_transition
-      rescue NameError
-        raise NameError, "Unrecognized place/transition: #{place_or_transition}"
-        # TODO: Exceptional Ruby
-      end
-    end
-    return self
-  end
-
-  # Inquirer whether the net includes a place / transition.
-  # 
-  def include? place_or_transition
-    pl = begin
-           place( place_or_transition )
-         rescue NameError
-           nil
-         end
-    return places.include? pl if pl
-    tr = begin
-           transition( place_or_transition )
-         rescue NameError
-           nil
-         end
-    return transitions.include? tr if tr
-    return false
+  def << element_id
+    element_type, element = begin
+                              [ :place,
+                                self.class.place( element_id ) ]
+                            rescue NameError, TypeError
+                              begin
+                                [ :transition,
+                                  self.class.transition( element_id ) ]
+                              rescue NameError, TypeError => err
+                                msg = "Current world contains no place or" +
+                                  "transition identified by #{element_id}!"
+                                raise TypeError, "#{msg} (#{err})"
+                              end
+                            end
+    case element_type
+    when :place then include_place( element )
+    when :transition then include_transition( element )
+    else fail "Mangled method YPetri::Net#<<!" end
   end
 
   # Is the net _functional_?
@@ -104,40 +103,37 @@ class YPetri::Net
   def functional?
     transitions.all? { |t| t.functional? }
   end
-    
+
   # Is the net <em>timed</em>?
   # 
   def timed?
-    transitions.all? { |t| t.timed? }
+    transitions.any? { |t| t.timed? }
   end
 
   # Creates a new simulation from the net.
   # 
-  def new_simulation( **nn )
-    YPetri::Simulation.new **nn.merge( net: self )
-  end
-
-  # Creates a new timed simulation from the net.
-  # 
-  def new_timed_simulation( **nn )
-    new_simulation( **nn ).aT &:timed?
+  def simulation( **settings )
+    Simulation().__new__ **settings
   end
 
   # Networks are equal when their places and transitions are equal.
   # 
   def == other
-    return false unless other.class_complies?( ç )
+    return false unless other.class_complies?( self.class )
     places == other.places && transitions == other.transitions
   end
 
   # Returns a string briefly describing the net.
   # 
   def to_s
-    "#<Net: " + ( name.nil? ? "%s" : "name: #{name}, %s" ) %
-      "#{places.size} places, #{transitions.size} transitions" + ">"
+    "#<Net: " +
+      ( name.nil? ? "%s" : "name: #{name}, %s" ) %
+      "#{pp.size rescue '∅'} places, #{tt.size rescue '∅'} transitions" + ">"
   end
 
   # Inspect string of the instance.
   # 
-  def inspect; to_s end
+  def inspect
+    to_s
+  end
 end # class YPetri::Net

data/lib/y_petri/place.rb

@@ -1,6 +1,5 @@
-# -*- coding: utf-8 -*-
+# encoding: utf-8
 
-require_relative 'dependency_injection'
 require_relative 'place/guard'
 require_relative 'place/arcs'
 
@@ -8,7 +7,13 @@ require_relative 'place/arcs'
 # 
 class YPetri::Place
   include NameMagic
-  include YPetri::DependencyInjection
+  include YPetri::World::Dependency
+
+  class << self
+    include YPetri::World::Dependency
+  end
+
+  delegate :world, to: "self.class"
 
   attr_reader :quantum
   attr_reader :guards

data/lib/y_petri/simulation/dependency.rb

@@ -0,0 +1,107 @@
+#encoding: utf-8
+
+# Place / transition collection mixin for parametrized classes of
+# YPetri::Simulation. Expects the module where it is included to define
+# +#simulation+ method returning the current simulation instance.
+#
+class YPetri::Simulation
+  module Dependency
+    delegate :Place,
+             :Transition,
+             :MarkingClamp,
+             :InitialMarkingObject,
+             :Places,
+             :Transitions,
+             :MarkingClamps,
+             :InitialMarking,
+             :net,
+             :p, :t, :e,
+             :pp, :tt, :ee,
+             :free_pp, :clamped_pp,
+             :ts_tt, :tS_tt, :Ts_tt, :TS_tt,
+             :t_tt, :T_tt, :s_tt, :S_tt,
+             :A_tt,
+             :f2a, :c2a,
+             :m_vector,
+             :recorder,
+             to: :simulation
+
+    # Delegates to the protected (and private) methods of simulation.
+    # 
+    def self.delegate_to_simulation! *symbols
+      symbols.each do |sym|
+        module_exec do
+          define_method sym do |*aa, &b| simulation.send sym, *aa, &b end
+        end
+      end
+    end
+
+    def element *args, &block
+      simulation.send :element, *args, &block
+    end
+
+    def place *args, &block
+      simulation.send :place, *args, &block
+    end
+
+    def transition *args, &block
+      simulation.send :transition, *args, &block
+    end
+
+    def elements *args, &block
+      simulation.send :elements, *args, &block
+    end
+
+    def places *args, &block
+      simulation.send :places, *args, &block
+    end
+
+    def transitions *args, &block
+      simulation.send :transitions, *args, &block
+    end
+
+    def free_places *args, &block
+      simulation.send :free_places, *args, &block
+    end
+
+    def clamped_places *args, &block
+      simulation.send :clamped_places, *args, &block
+    end
+
+    def ts_transitions *args, &block
+      simulation.send :ts_transitions, *args, &block
+    end
+
+    def tS_transitions *args, &block
+      simulation.send :tS_transitions, *args, &block
+    end
+
+    def Ts_transitions *args, &block
+      simulation.send :Ts_transitions, *args, &block
+    end
+
+    def TS_transitions *args, &block
+      simulation.send :TS_transitions, *args, &block
+    end
+
+    def t_transitions *args, &block
+      simulation.send :t_transitions, *args, &block
+    end
+
+    def T_transitions *args, &block
+      simulation.send :T_transitions, *args, &block
+    end
+
+    def s_transitions *args, &block
+      simulation.send :s_transitions, *args, &block
+    end
+
+    def S_transitions *args, &block
+      simulation.send :S_transitions, *args, &block
+    end
+
+    def A_transitions *args, &block
+      simulation.send :A_transitions, *args, &block
+    end
+  end # class Dependency
+end # class YPetri::Simulation

data/lib/y_petri/simulation/element_representation.rb

@@ -0,0 +1,20 @@
+#encoding: utf-8
+
+# Representation of a YPetri::Place inside a YPetri::Simulation instance.
+#
+class YPetri::Simulation
+  class ElementRepresentation
+    include NameMagic
+    include Dependency
+
+    attr_reader :source # source place
+
+    delegate :simulation, to: "self.class"
+
+    # Expect a single YPetri place as an argument.
+    # 
+    def initialize net_element_id
+      @source = net.element( net_element_id )
+    end
+  end # class ElementRepresentation
+end # class YPetri::Simulation

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

@@ -0,0 +1,57 @@
+#encoding: utf-8
+
+# Simulation mixin providing access to elements (an element is either a
+# place, or a transition -- see also mixins +Places::Access+ and
+# +Transitions::Access+.
+# 
+class YPetri::Simulation::Elements
+  module Access
+    # Does an element belong to the simulation?
+    # 
+    def includes?( id )
+      includes_place?( id ) || includes_transition?( id )
+    end
+    alias include? includes?
+
+    # Element of the simulation (belonging to the net).
+    # 
+    def e( id )
+      element( id ).source
+    end
+
+    # Elements of the simulation (belonging to the net).
+    # 
+    def ee( ids=nil )
+      elements( ids ).sources
+    end
+
+    # Names of the simulation's elements. Arguments, if any, are treated
+    # analogically to the +#elements+ method.
+    # 
+    def en ids=nil
+      elements( ids ).names
+    end
+
+    protected
+
+    # Element instance identification.
+    # 
+    def element( id )
+      if include_place? id
+        return place( id )
+      end
+      if include_transition? id
+        return transition( id )
+      end
+      fail TypeError, "No element #{id} in the simulation!"
+    end
+
+    # Without arguments, returns all the elements (places + transitions). If
+    # arguments are given, they are converted into elements.
+    # 
+    def elements ids=nil
+      return places + transitions if ids.nil?
+      ids.map { |id| element id }
+    end
+  end # module Access
+end # class YPetri::Simulation::Elements

data/lib/y_petri/simulation/elements.rb

@@ -0,0 +1,45 @@
+# Basic elements of a simulation, a mixin intended for YPetri::Simulation.
+#
+class YPetri::Simulation
+  class Elements < Array
+    include Dependency
+    
+    class << self
+      # New collection constructor
+      #
+      def load collection
+        new.tap { |inst| inst.load collection }
+      end
+    end
+
+    delegate :simulation, to: "self.class"
+    
+    # Loads elements to this collection.
+    #
+    def load elements
+      elements.each{ |e| push e }
+    end
+    
+    # Creates a subset of this collection (of the same class).
+    #
+    def subset element_ids=nil, &block
+      if block_given? then
+        msg = "If block is given, arguments are not allowed!"
+        fail ArgumentError, msg unless element_ids.nil?
+        self.class.load select( &block )
+      else
+        ee = elements( element_ids )
+        ee.all? { |e| include? e } or
+          fail TypeError, "All subset elements must be in the collection."
+        self.class.load( ee )
+      end
+    end
+
+    # Returns an array of the element sources (elemens in the original net).
+    # 
+    def sources
+      map &:source
+    end
+    alias to_sources sources
+  end
+end

data/lib/y_petri/simulation/feature_set.rb

@@ -0,0 +1,21 @@
+# Basic elements of a simulation, a mixin intended for YPetri::Simulation.
+#
+class YPetri::Simulation
+  # Represents a set of features of a simulation state.
+  # 
+  class FeatureSet
+    include DependencyInjection
+
+    attr_reader :marking, :firing, :delta
+
+    # Initializes the feature set.
+    # 
+    def initialize marking: [], firing: [],
+                   delta: { places: [], transitions: [] }
+      @marking = x
+
+      @firing = 
+      @marking, @firing, @delta = marking, firing, delta
+    end
+  end # class FeatureSet
+end # YPetri::Simulation

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

@@ -0,0 +1,55 @@
+#encoding: utf-8
+
+# Simulation mixin providing access to the initial marking.
+#
+class YPetri::Simulation::InitialMarking
+  module Access
+    # Without arguments, acts as a getter of @initial_marking. If arguments are
+    # supplied, they must identify free places, and are mapped to their initial
+    # marking.
+    # 
+    def initial_marking ids=nil
+      if ids.nil? then
+        @initial_marking or
+          fail TypeError, "InitialMarking object not instantiated yet!"
+      else
+        free_places( ids ).map { |pl| initial_marking[ place( pl ) ] }
+      end
+    end
+
+    # Without arguments, returns the marking of all the simulation's places
+    # (both free and clamped) as it appears after reset. If arguments are
+    # supplied, they must identify places, and are converted to either their
+    # initial marking (free places), or their clamp value (clamped places).
+    # 
+    def im ids=nil
+      return im( places ) if ids.nil?
+      places( ids ).map { |pl|
+        pl.free? ? initial_marking( of: pl ) : marking_clamp( of: pl )
+      }
+    end
+
+    # Returns initial marking vector for free places. Like +#initial_marking+,
+    # but returns a column vector.
+    # 
+    def initial_marking_vector ids=nil
+      initial_marking( ids ).to_column_vector
+    end
+
+    # Returns initial marking vector for all places. Like +#initial_marking+,
+    # but returns a column vector.
+    # 
+    def im_vector ids=nil
+      im( ids ).to_column_vector
+    end
+
+    private
+
+    # Sets the initial marking of a place (frontend of +InitialMarking#set+).
+    # 
+    def set_initial_marking( of: (fail ArgumentError), to: (fail ArgumentError) )
+      initial_marking.set( of, to: to )
+    end
+  end # module Access
+end # class YPetri::Simulation::InitialMarking
+

data/lib/y_petri/simulation/initial_marking.rb

@@ -0,0 +1,15 @@
+# Manages the initial marking of a simulation.
+#
+class YPetri::Simulation
+  class InitialMarking < PlaceMapping
+    # Sets the initial marking for a given place to a given value.
+    # 
+    def set( place_id, to: (fail ArgumentError) )
+      fail TypeError, "The place #{place_id} is already clamped!" if
+        begin # fails if marking clamps are not set yet
+          place( place_id ).clamped?
+        rescue TypeError, NoMethodError; end
+      super
+    end
+  end # class InitialMarking
+end # class YPetri::Simulation

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

@@ -0,0 +1,34 @@
+#encoding: utf-8
+
+# Simulation mixin providing access to the marking clamps.
+#
+class YPetri::Simulation::MarkingClamps
+  module Access
+    # Without arguments, acts as a getter of the @marking_clamp hash. If
+    # arguments are supplied, they must identify clamped places, and are mapped
+    # to their clamp values.
+    # 
+    def marking_clamps ids=nil
+      if ids.nil? then
+        @marking_clamps or
+          fail TypeError, "MarkingClamps object not instantiated yet!"
+      else
+        clamped_places( ids ).map { |p| marking_clamp of: p }
+      end
+    end
+    alias clamps marking_clamps
+
+    # Marking clamp identification.
+    # 
+    def marking_clamp( of: (fail ArgumentError) )
+      marking_clamps.clamp_of( of )
+    end
+
+    # Sets the marking clamp of a place (frontend of +InitialMarking#set+).
+    # 
+    def set_marking_clamp( of: (fail ArgumentError), to: (fail ArgumentError) )
+      marking_clamps.set( of, to: to )
+    end
+  end # module Access
+end # class YPetri::Simulation::MarkingClamps
+

data/lib/y_petri/simulation/marking_clamps.rb

@@ -0,0 +1,18 @@
+# Collection of marking clamps for YPetri::Simulation.
+#
+class YPetri::Simulation
+  class MarkingClamps < PlaceMapping
+    alias clamp_of of
+
+    # Sets the clamp for a given place to a given value.
+    # 
+    def set place_id, to: (fail ArgumentError, "No :to value!")
+      pl = place( place_id )
+      # free places change into clamped ones.
+      initial_marking.delete pl if begin # fails if initial marking not set yet
+                                     pl.free?
+                                   rescue TypeError, NoMethodError; end
+      super
+    end
+  end # class MarkingClamps
+end # class YPetri::Simulation