pione 0.3.2 → 0.4.0

data/lib/pione/pnml/input-merge-complement.rb

@@ -0,0 +1,78 @@
+module Pione
+  module PNML
+    # `InputMergeComplement` is a net rewriting rule. This rule complements the
+    # name of input-merged empty place. For example, the net like the following
+    #
+    #     'p1' --> empty transition --+
+    #                                 |
+    #     'p2' --> empty transition --+--> empty place -> A
+    #                                 |
+    #     'p3' --> empty transition --+
+    #
+    # is rewritten as the following.
+    #
+    #     'p1' --> empty transition --+
+    #                                 |
+    #     'p2' --> empty transition --+--> 'p1' or 'p2' or 'p3' -> A
+    #                                 |
+    #     'p3' --> empty transition --+
+    #
+    module InputMergeComplement
+      # Find subjects(source transitions and target palce) of this rule from the
+      # net. The conditions are followings:
+      #
+      # - There is an empty target place.
+      # - There are more than 2 empty source transitions.
+      # - Each source transition has only one named place as the input condition.
+      # - There are arcs that connect sources and the target.
+      #
+      # @param net [PNML::Net]
+      #   rewriting target net
+      # @return [Array]
+      #   source transitions and target place
+      def self.find_subjects(net)
+        net.places.each do |place|
+          # target place should have no names
+          next unless place.empty_name?
+
+          # collect transitions
+          transitions = net.find_all_transitions_by_target_id(place.id).select do |transition|
+            arcs = net.find_all_arcs_by_target_id(transition.id)
+            if arcs.size == 1
+              _place = net.find_place(arcs.first.source_id)
+              transition.empty_name? and Perspective.file?(_place)
+            end
+          end
+
+          # there should be more than 2 transitions
+          next unless transitions.size > 1
+
+          return [transitions, place]
+        end
+
+        return nil
+      end
+
+      # Rewrite subject place's name by using subject transitions.
+      #
+      # @param net [PNML::Net]
+      #   rewriting target net
+      # @param subjects [Array]
+      #   source transitions and target place
+      # @return [void]
+      def self.rewrite(net, subjects)
+        transitions, place = subjects
+
+        # build a new name
+        new_name = transitions.map do |transition|
+          arcs = net.find_all_arcs_by_target_id(transition.id)
+          _place = net.find_place(arcs.first.source_id)
+          Perspective.normalize_data_name(_place.name)
+        end.sort.join(" or ")
+
+        # update the place name
+        place.name = "%s%s" % [Perspective.modifier(place.name), new_name]
+      end
+    end
+  end
+end

data/lib/pione/pnml/input-parallelization-complement.rb

@@ -0,0 +1,75 @@
+module Pione
+  module PNML
+    # `InputParallelizationComplement` is a net rewriting rule. This rule
+    # complements names of empty places that form input parallelization
+    # pattern. For example, the net likes the following
+    #
+    #                                 +--> empty place --> A
+    #                                 |
+    #     'p1' --> empty transition --+--> empty place --> B
+    #                                 |
+    #                                 +--> empty place --> C
+    #
+    # is rewritten as the following.
+    #
+    #                                 +--> 'p1' --> A
+    #                                 |
+    #     'p1' --> empty transition --+--> 'p1' --> B
+    #                                 |
+    #                                 +--> 'p1' --> C
+    #
+    module InputParallelizationComplement
+      # Find subjects(input place and target places) of this rule from the
+      # net. The conditions are followings:
+      #
+      # - There is an empty source transition. It has only one named place as an
+      #   input.
+      # - There are more than 2 target places that includes empty place.
+      # - There are arcs that connect the source and targets.
+      #
+      # @param net [PNML::Net]
+      #   rewriting target net
+      # @return [Array]
+      #   input place and target places
+      def self.find_subjects(net)
+        net.transitions.each do |transition|
+          # source transition should have no names
+          next unless transition.empty_name?
+
+          # transition should have only one named input
+          input_places = net.find_all_places_by_target_id(transition.id)
+          unless input_places.size == 1 and Perspective.file?(input_places.first)
+            next
+          end
+
+          # collect places
+          output_places = net.find_all_places_by_source_id(transition.id)
+          next unless output_places.all? {|output_place| output_place.empty_name?}
+
+          # there should be more than 2 places
+          next unless output_places.size > 1
+
+          return [input_places.first, output_places]
+        end
+
+        return nil
+      end
+
+      # Rewrite targe place's name same as input place's name.
+      #
+      # @param net [PNML::Net]
+      #   rewriting target net
+      # @param subjects [Array]
+      #   input place and target places
+      # @return [void]
+      def self.rewrite(net, subjects)
+        input_place, target_places = subjects
+
+        # rewrite names of target places
+        target_places.each do |place|
+          place.name = Perspective.normalize_data_name(input_place.name)
+        end
+      end
+    end
+  end
+end

data/lib/pione/pnml/input-reduction.rb

@@ -0,0 +1,80 @@
+module Pione
+  module PNML
+    # `InputReduction` is a net rewriting rule. This rule removes unnecessary
+    # input nodes of transitions by following criteria. For example, the net
+    # likes the following(A and B are transitions)
+    #
+    #     A --> place --> empty transition --> empty place --> B
+    #
+    # is rewritten as the following.
+    #
+    #     A -> place -> B
+    #
+    module InputReduction
+      # Return subjects(source transtion, target place, and the arc) if the net
+      # satisfies input reduction's condtions. The conditions are followings:
+      #
+      # - There is an empty source transition.
+      # - There is an empty target place. It is an input of named transition.
+      # - There is an arc that connects the source and the target.
+      def self.find_subjects(net)
+        net.transitions.each do |rule|
+          # rule has its name
+          next unless Perspective.named?(rule)
+
+          # find source places
+          net.find_all_places_by_target_id(rule.id).each do |place|
+            # the source place has empty name
+            next unless Perspective.empty?(place)
+
+            # find transtions that generates the source place
+            transitions = net.find_all_transitions_by_target_id(place.id)
+
+            # only one transtion
+            if transitions.size == 1
+              transition = transitions.first
+
+              # the transition is connected to only one place at target side
+              if net.find_all_places_by_source_id(transition.id).size == 1
+                # the transition has empty name
+                if Perspective.empty?(transition)
+                  return [transition, place, net.find_arc(transition.id, place.id)]
+                end
+              end
+            end
+          end
+        end
+
+        return nil
+      end
+
+      # Rewrite the net with subjects by the following way.
+      #
+      # - Remove the subject place.
+      # - Remove the subject transition.
+      # - Remove the subject and related arcs.
+      # - Connect discontinuous nodes by new arcs.
+      def self.rewrite(net, subjects)
+        transition, place, arc = subjects
+
+        # remove subjects from the net
+        net.places.delete(place)
+        net.transitions.delete(transition)
+        net.arcs.delete(arc)
+
+        # remove related arcs
+        input_arcs = net.find_all_arcs_by_target_id(transition.id)
+        input_arcs.each {|arc| net.arcs.delete(arc)}
+        output_arcs = net.find_all_arcs_by_source_id(place.id)
+        output_arcs.each {|arc| net.arcs.delete(arc)}
+
+        # append new arcs
+        input_arcs.each do |input_arc|
+          output_arcs.each do |output_arc|
+            net.arcs << Arc.new(net, net.generate_id, input_arc.source_id, output_arc.target_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pione/pnml/invalid-arc-elimination.rb

@@ -0,0 +1,41 @@
+module Pione
+  module PNML
+    # `InvalidArcElimination` is a net rewriting rule. This rule removes invalid
+    # arcs from nets.
+    module InvalidArcElimination
+      # Find subjects(an invalid arc) by following criteria.
+      #
+      # - There is a arc.
+      # - It should connect source place and target transition, or source
+      #   transition and target place.
+      def self.find_subjects(net)
+        net.arcs.each do |arc|
+          source_transition = net.find_transition(arc.source_id)
+          source_place = net.find_place(arc.source_id)
+          target_transition = net.find_transition(arc.target_id)
+          target_place = net.find_place(arc.target_id)
+
+          # arc from transition to place
+          cond1 = not(source_transition.nil?) && not(target_place.nil?)
+
+          # arc from place to transition
+          cond2 = not(source_place.nil?) && not(target_transition.nil?)
+
+          unless cond1 or cond2
+            return [arc]
+          end
+        end
+
+        return nil
+      end
+
+      # Rewrite the net by eliminating isolated node.
+      def self.rewrite(net, subjects)
+        arc = subjects.first
+
+        # eliminate
+        net.arcs.delete(arc)
+      end
+    end
+  end
+end

data/lib/pione/pnml/io-expansion.rb

@@ -0,0 +1,88 @@
+module Pione
+  module PNML
+    # `IOException` is a net rewriting rule. This rule transforms nets by
+    # expanding file places that are sandwiched by source and target rule
+    # transitions. For example, the net like the following
+    #
+    #    A --> 'p1' --> B
+    #
+    # is written as the following.
+    #
+    #    A --> 'p1' --> empty transition --> 'p1' --> B
+    #
+    module IOExpansion
+      # Find subjects(sandwiched place and target side arcs) of this rule from
+      # the net. The conditions are followings:
+      #
+      # - There is a file place.
+      # - There are rule transitions.
+      # - There are arcs that connect the file place and the rule transitions.
+      #
+      # @param net [PNML::Net]
+      #   rewriting target net
+      # @return [Array]
+      #   sandwiched place and target side arcs
+      def self.find_subjects(net)
+        net.transitions.each do |transition|
+          # transition should be a rule
+          next unless Perspective.rule?(transition)
+
+          net.find_all_places_by_source_id(transition.id).each do |place|
+            # place should be a file
+            next unless Perspective.file?(place)
+
+            # collect target side arcs
+            all_target_arcs = net.find_all_arcs_by_source_id(place.id)
+            target_arcs = all_target_arcs.select do |arc|
+              transition = net.find_transition(arc.target_id)
+              transition and Perspective.rule?(transition)
+            end
+            next unless target_arcs.size > 0
+
+            # return subjects
+            return [place, target_arcs]
+          end
+        end
+
+        return nil
+      end
+
+      # Rewrite the net with subjects by the following way.
+      #
+      # - Remove subject target arcs
+      # - Add a copied place and an accommodation transition.
+      # - Connect discontinuous nodes by new arcs.
+      #
+      # @param net [PNML::Net]
+      #   rewriting target net
+      # @param subjects [Array]
+      #   sandwiched place and target side arcs
+      # @return [void]
+      def self.rewrite(net, subjects)
+        place, target_arcs = subjects
+
+        # remove arcs
+        target_arcs.each {|arc| net.arcs.delete(arc)}
+
+        # create an expanded place
+        expanded_place = Place.new(net, net.generate_id, place.name)
+        net.places << expanded_place
+
+        # create an accommodation transition
+        transition = Transition.new(net, net.generate_id)
+        net.transitions << transition
+
+        # connect original place and accommodation transition
+        net.arcs << Arc.new(net, net.generate_id, place.id, transition.id)
+
+        # connect accommodation transition and expanded place
+        net.arcs << Arc.new(net, net.generate_id, transition.id, expanded_place.id)
+
+        # connect expanded place and rule transtions
+        target_arcs.each do |arc|
+          net.arcs << Arc.new(net, net.generate_id, expanded_place.id, arc.target_id)
+        end
+      end
+    end
+  end
+end

data/lib/pione/pnml/isolated-element-elimination.rb

@@ -0,0 +1,32 @@
+module Pione
+  module PNML
+    # `IsolatedElementElimination` is a net rewriting rule. This rule removes
+    # isolated elememts from nets.
+    module IsolatedElementElimination
+      # Find subjects(an isolated element) by following criteria.
+      #
+      # - There is a place or transition.
+      # - It has no arcs.
+      def self.find_subjects(net)
+        (net.places + net.transitions).each do |node|
+          input_arcs = net.find_all_arcs_by_source_id(node.id)
+          output_arcs = net.find_all_arcs_by_target_id(node.id)
+          if input_arcs.empty? and output_arcs.empty?
+            return [node]
+          end
+        end
+
+        return nil
+      end
+
+      # Rewrite the net by eliminating isolated node.
+      def self.rewrite(net, subjects)
+        subjects.each do |node|
+          # eliminate the node
+          net.transitions.delete(node)
+          net.places.delete(node)
+        end
+      end
+    end
+  end
+end

data/lib/pione/pnml/net-rewriter.rb

@@ -0,0 +1,44 @@
+module Pione
+  module PNML
+    # `NetRewriter` is a class for rewriting PNML's net by PIONE's rewriting
+    # rules likes "input reduction", "output reduction", "IO expansion", and
+    # etc.
+    class NetRewriter
+      # Create a new net rewriter. Rewriting rules are setuped by the block.
+      #
+      #     PNML::NetRewriter.new do |rules|
+      #       rules << PNML::InputReduction
+      #       rules << PNML::OutputReduction
+      #       rules << PNML::IOExpansion
+      #     end
+      def initialize(&b)
+        @rules = []
+        if block_given?
+          yield @rules
+        end
+      end
+
+      # Rewrite the net by rewriting rules recursively.
+      #
+      # @param net [PNML::Net]
+      #   a net that is a target of this transformation
+      # @return [void]
+      def rewrite(net)
+        # find rewriting subjects
+        rule, subjects = @rules.inject(nil) do |res, _rule|
+          if res.nil? and _subjects = _rule.find_subjects(net)
+            [_rule, _subjects]
+          else
+            res
+          end
+        end
+
+        # rewrite the net with subjects and go next
+        if subjects
+          rule.rewrite(net, subjects)
+          rewrite(net)
+        end
+      end
+    end
+  end
+end