y_petri 2.1.3 → 2.1.6

data/lib/y_petri/net/state/feature/flux.rb

@@ -1,58 +1,54 @@
 # encoding: utf-8
 
-class YPetri::Net::State
-  class Feature
-    # Flux of a Petri net TS transition.
-    # 
-    class Flux < Feature
-      attr_reader :transition
-
-      class << self
-        def parametrize *args
-          Class.instance_method( :parametrize ).bind( self ).( *args ).tap do |ç|
-            ç.instance_variable_set( :@instances,
-                                     Hash.new do |hsh, id|
-                                       case id
-                                       when Firing then
-                                         hsh[ id.transition ]
-                                       when ç.net.Transition then
-                                         hsh[ id ] = ç.__new__( id )
-                                       else
-                                         hsh[ ç.net.transition( id ) ]
-                                       end
-                                     end )
-          end
-        end
-
-        attr_reader :instances
-
-        alias __new__ new
-
-        def new id
-          instances[ id ]
-        end
-
-        def of transition_id
-          new transition_id
-        end
+# Flux of a Petri net TS transition.
+# 
+class YPetri::Net::State::Feature::Flux < YPetri::Net::State::Feature
+  attr_reader :transitionn
+
+  class << self
+    def parametrize *args
+      Class.instance_method( :parametrize ).bind( self ).( *args ).tap do |ç|
+        ç.instance_variable_set( :@instances,
+                                 Hash.new do |hsh, id|
+                                   case id
+                                   when self then
+                                     hsh[ id.transition ]
+                                   when ç.net.Transition then
+                                     hsh[ id ] = ç.__new__( id )
+                                   else
+                                     hsh[ ç.net.transition( id ) ]
+                                   end
+                                 end )
       end
-
-      def initialize id
-        @transition = net.transition( id.is_a?( Flux ) ? id.transition : id )
-      end
-
-      def extract_from arg, **nn
-        case arg
-        when YPetri::Simulation then
-          arg.send( :TS_transitions, [ transition ] ).flux.first
-        else
-          fail TypeError, "Argument type not supported!"
-        end
-      end
-
-      def label
-        "Φ:#{transition.name}"
-      end
-    end # class Flux
-  end # class Feature
-end # YPetri::Net::State
+    end
+
+    attr_reader :instances
+
+    alias __new__ new
+
+    def new id
+      instances[ id ]
+    end
+
+    def of transition_id
+      new transition_id
+    end
+  end
+
+  def initialize id
+    @transition = net.transition( id.is_a?( Flux ) ? id.transition : id )
+  end
+
+  def extract_from arg, **nn
+    case arg
+    when YPetri::Simulation then
+      arg.send( :TS_transitions, [ transition ] ).flux.first
+    else
+      fail TypeError, "Argument type not supported!"
+    end
+  end
+
+  def label
+    "Φ:#{transition.name}"
+  end
+end # class YPetri::Net::State::Feature::Flux

data/lib/y_petri/net/state/feature/gradient.rb

@@ -1,75 +1,71 @@
 # encoding: utf-8
 
-class YPetri::Net::State
-  class Feature
-    # Gradient of a Petri net place caused by a certain set of T transitions.
-    # 
-    class Gradient < Feature
-      attr_reader :place, :transitions
+# Gradient of a Petri net place caused by a certain set of T transitions.
+# 
+class YPetri::Net::State::Feature::Gradient < YPetri::Net::State::Feature
+  attr_reader :place, :transitions
 
-      class << self
-        def parametrize *args
-          Class.instance_method( :parametrize ).bind( self ).( *args ).tap do |ç|
-            # First, prepare the hash of instances.
-            hsh = Hash.new do |ꜧ, id|
-              if id.is_a? Gradient then
-                ꜧ[ [ id.place, transitions: id.transitions.sort( &:object_id ) ] ]
+  class << self
+    def parametrize *args
+      Class.instance_method( :parametrize ).bind( self ).( *args ).tap do |ç|
+        # First, prepare the hash of instances.
+        hsh = Hash.new do |ꜧ, id|
+          if id.is_a? self then
+            ꜧ[ [ id.place, transitions: id.transitions.sort( &:object_id ) ] ]
+          else
+            p = id.fetch( 0 )
+            tt = id
+              .fetch( 1 )
+              .fetch( :transitions )
+            if p.is_a? ç.net.Place and tt.all? { |t| t.is_a? ç.net.Transition }
+              if tt == tt.sort then
+                ꜧ[ id ] = ç.__new__( *id )
               else
-                p = id.fetch( 0 )
-                tt = id
-                  .fetch( 1 )
-                  .fetch( :transitions )
-                if p.is_a? ç.net.Place and tt.all? { |t| t.is_a? ç.net.Transition }
-                  if tt == tt.sort then
-                    ꜧ[ id ] = ç.__new__( *id )
-                  else
-                    ꜧ[ [ p, transitions: tt.sort ] ]
-                  end
-                else
-                  ꜧ[ [ ç.net.place( p ), transitions: ç.net.transitions( tt ) ] ]
-                end
+                ꜧ[ [ p, transitions: tt.sort ] ]
               end
+            else
+              ꜧ[ [ ç.net.place( p ), transitions: ç.net.transitions( tt ) ] ]
             end
-            # And then, assign it to the :@instances variable.
-            ç.instance_variable_set :@instances, hsh
           end
         end
+        # And then, assign it to the :@instances variable.
+        ç.instance_variable_set :@instances, hsh
+      end
+    end
 
-        attr_reader :instances
+    attr_reader :instances
 
-        alias __new__ new
+    alias __new__ new
 
-        def new *args
-          return instances[ *args ] if args.size == 1
-          instances[ args ]
-        end
+    def new *args
+      return instances[ *args ] if args.size == 1
+      instances[ args ]
+    end
 
-        def of *args
-          new *args
-        end
-      end
+    def of *args
+      new *args
+    end
+  end
 
-      def initialize *id
-        @place = net.place id.fetch( 0 )
-        @transitions = net.transitions id.fetch( 1 ).fetch( :transitions )
-      end
+  def initialize *id
+    @place = net.place id.fetch( 0 )
+    @transitions = net.transitions id.fetch( 1 ).fetch( :transitions )
+  end
 
-      def extract_from arg, **nn
-        case arg
-        when YPetri::Simulation then
-          arg.send( :T_transitions, transitions ).gradient.fetch( place )
-        else
-          fail TypeError, "Argument type not supported!"
-        end
-      end
+  def extract_from arg, **nn
+    case arg
+    when YPetri::Simulation then
+      arg.send( :T_transitions, transitions ).gradient.fetch( place )
+    else
+      fail TypeError, "Argument type not supported!"
+    end
+  end
 
-      def to_s
-        place.name
-      end
+  def to_s
+    place.name
+  end
 
-      def label
-        "∂:#{place.name}:#{transitions.size}tt"
-      end
-    end # class Gradient
-  end # class Feature
-end # YPetri::Net::State
+  def label
+    "∂:#{place.name}:#{transitions.size}tt"
+  end
+end # class YPetri::Net::State::Feature::Gradient

data/lib/y_petri/net/state/feature/marking.rb

@@ -1,62 +1,58 @@
 # encoding: utf-8
 
-class YPetri::Net::State
-  class Feature
-    # Marking of a Petri net place.
-    # 
-    class Marking < Feature
-      attr_reader :place
-
-      class << self
-        def parametrize *args
-          Class.instance_method( :parametrize ).bind( self ).( *args ).tap do |ç|
-            ç.instance_variable_set( :@instances,
-                                     Hash.new do |hsh, id|
-                                       case id
-                                       when Marking then
-                                         hsh[ id.place ]
-                                       when ç.net.Place then
-                                         hsh[ id ] = ç.__new__( id )
-                                       else
-                                         hsh[ ç.net.place( id ) ]
-                                       end
-                                     end )
-          end
-        end
-
-        attr_reader :instances
-
-        alias __new__ new
-
-        def new id
-          instances[ id ]
-        end
-
-        def of id
-          new id
-        end
+# Marking of a Petri net place.
+# 
+class YPetri::Net::State::Feature::Marking < YPetri::Net::State::Feature
+  attr_reader :place
+
+  class << self
+    def parametrize *args
+      Class.instance_method( :parametrize ).bind( self ).( *args ).tap do |ç|
+        ç.instance_variable_set( :@instances,
+                                 Hash.new do |hsh, id|
+                                   case id
+                                   when self then
+                                     hsh[ id.place ]
+                                   when ç.net.Place then
+                                     hsh[ id ] = ç.__new__( id )
+                                   else
+                                     hsh[ ç.net.place( id ) ]
+                                   end
+                                 end )
       end
-
-      def initialize place
-        @place = net.place( place )
-      end
-
-      def extract_from arg, **nn
-        case arg
-        when YPetri::Simulation then
-          arg.m( [ place ] ).first
-        else
-          fail TypeError, "Argument type not supported!"
-        end
-      end
-
-      def to_s
-        place.name
-      end
-
-      def label
-        ":#{place.name}"
-      end
-    end # class Marking
-  end # class Feature
-end # YPetri::Net::State
+    end
+
+    attr_reader :instances
+
+    alias __new__ new
+
+    def new id
+      instances[ id ]
+    end
+
+    def of id
+      new id
+    end
+  end
+
+  def initialize place
+    @place = net.place( place )
+  end
+
+  def extract_from arg, **nn
+    case arg
+    when YPetri::Simulation then
+      arg.m( [ place ] ).first
+    else
+      fail TypeError, "Argument type not supported!"
+    end
+  end
+
+  def to_s
+    place.name
+  end
+
+  def label
+    ":#{place.name}"
+  end
+end # YPetri::Net::State::Feature::Marking

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

@@ -1,79 +1,77 @@
 # encoding: utf-8
 
-class YPetri::Net::State
-  # A feature of a Petri net.
-  #
-  class Feature
-    require_relative 'feature/marking'
-    require_relative 'feature/firing'
-    require_relative 'feature/gradient'
-    require_relative 'feature/flux'
-    require_relative 'feature/delta'
+# A feature of a Petri net.
+#
+class YPetri::Net::State::Feature
+  require_relative 'feature/marking'
+  require_relative 'feature/firing'
+  require_relative 'feature/gradient'
+  require_relative 'feature/flux'
+  require_relative 'feature/delta'
 
-    class << self
-      def parametrize parameters
-        Class.new( self ).tap do |ç|
-          parameters.each_pair { |symbol, value|
-            ç.define_singleton_method symbol do value end
-          }
-          sç = ç.State
-          ç.instance_variable_set :@Marking, Marking.parametrize( State: sç )
-          ç.instance_variable_set :@Firing, Firing.parametrize( State: sç )
-          ç.instance_variable_set :@Gradient, Gradient.parametrize( State: sç )
-          ç.instance_variable_set :@Flux, Flux.parametrize( State: sç )
-          ç.instance_variable_set :@Delta, Delta.parametrize( State: sç )
+  class << self
+    def parametrize parameters
+      Class.new( self ).tap do |ç|
+        parameters.each_pair do |ß, val|
+          ç.define_singleton_method ß do val end
         end
+        sç = ç.State
+        ç.instance_variable_set :@Marking, Marking.parametrize( State: sç )
+        ç.instance_variable_set :@Firing, Firing.parametrize( State: sç )
+        ç.instance_variable_set :@Gradient, Gradient.parametrize( State: sç )
+        ç.instance_variable_set :@Flux, Flux.parametrize( State: sç )
+        ç.instance_variable_set :@Delta, Delta.parametrize( State: sç )
       end
+    end
 
-      delegate :net,
-               to: "State()"
+    delegate :net,
+             to: "State()"
 
-      def Marking id=L!
-        return @Marking if id.local_object?
-        case id
-        when Marking() then id
-        when Marking then Marking().of( id.place )
-        else Marking().of( id ) end # assume it's a place
-      end
+    def Marking id=L!
+      return @Marking if id.local_object?
+      case id
+      when Marking() then id
+      when Marking then Marking().of( id.place )
+      else Marking().of( id ) end # assume it's a place
+    end
 
-      def Firing id=L!
-        return @Firing if id.local_object?
-        case id
-        when Firing() then id
-        when Firing then Firing().of( id.transition )
-        else Firing().of( id ) end # assume it's a place
-      end
+    def Firing id=L!
+      return @Firing if id.local_object?
+      case id
+      when Firing() then id
+      when Firing then Firing().of( id.transition )
+      else Firing().of( id ) end # assume it's a place
+    end
 
-      def Gradient id=L!, transitions: net.T_tt
-        return @Gradient if id.local_object?
-        case id
-        when Gradient() then id
-        when Gradient then
-          Gradient().of( id.place, transitions: id.transitions )
-        else Gradient().of( id, transitions: transitions ) end # assume it's a place
-      end
+    def Gradient id=L!, transitions: net.T_tt
+      return @Gradient if id.local_object?
+      case id
+      when Gradient() then id
+      when Gradient then
+        Gradient().of( id.place, transitions: id.transitions )
+      else Gradient().of( id, transitions: transitions ) end # assume it's a place
+    end
 
-      def Flux id=L!
-        return @Flux if id.local_object?
-        case id
-        when Flux() then id
-        when Flux then Flux().of( id.transition )
-        else Flux().of( id ) end # assume it's a place
-      end
+    def Flux id=L!
+      return @Flux if id.local_object?
+      case id
+      when Flux() then id
+      when Flux then Flux().of( id.transition )
+      else Flux().of( id ) end # assume it's a place
+    end
 
-      def Delta id=L!, transitions: net.tt
-        return @Delta if id.local_object?
-        case id
-        when Delta() then id
-        when Delta then
-          Delta().of( id.place, transitions: id.transitions )
-        else Delta().of( id, transitions: transitions ) end # assume it's a place
-      end
-    end # class << self
+    def Delta id=L!, transitions: net.tt
+      return @Delta if id.local_object?
+      case id
+      when Delta() then id
+      when Delta then
+        Delta().of( id.place, transitions: id.transitions )
+      else Delta().of( id, transitions: transitions ) end # assume it's a place
+    end
+  end # class << self
 
-    delegate :net,
-             :State,
-             :Marking, :Firing, :Gradient, :Flux, :Delta,
-             to: "self.class"
-  end # class Feature
-end # YPetri::Net::State
+  delegate :net,
+           :State,
+           :Marking, :Firing, :Gradient, :Flux, :Delta,
+           to: "self.class"
+end # class YPetri::Net::State::Feature