axiom-optimizer 0.1.0

data/lib/axiom/optimizer/algebra/union.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Algebra
+
+      # Abstract base class representing Union optimizations
+      class Union < Relation::Operation::Binary
+
+        # Optimize when operands are equal
+        class EqualOperands < self
+          include Relation::Operation::Binary::EqualOperands
+
+          # A Union with equal operands is a noop
+          #
+          # @return [Relation]
+          #
+          # @api private
+          def optimize
+            left
+          end
+
+        end # class EqualOperands
+
+        # Optimize when the left operand is empty
+        class EmptyLeft < self
+          include Relation::Operation::Binary::EmptyLeft
+
+          # A Union with an empty left operand is equivalent to the right
+          #
+          # @return [Relation]
+          #
+          # @api private
+          def optimize
+            right
+          end
+
+        end # class EmptyLeft
+
+        # Optimize when the right operand is empty
+        class EmptyRight < self
+          include Relation::Operation::Binary::EmptyRight
+
+          # A Union with an empty right operand is equivalent to the left
+          #
+          # @return [Relation]
+          #
+          # @api private
+          def optimize
+            left
+          end
+
+        end # class EmptyRight
+
+        Axiom::Algebra::Union.optimizer = chain(
+          EqualOperands,
+          EmptyRight,
+          EmptyLeft,
+          OrderLeft,
+          OrderRight,
+          MaterializedOperands,
+          UnoptimizedOperands
+        )
+
+      end # class Union
+    end # module Algebra
+  end # class Optimizer
+end # module Axiom

data/lib/axiom/optimizer/function.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+
+    # Mixin for function optimizations
+    module Function
+
+      # Optimize the operand if possible
+      #
+      # @param [#optimize, Object] operand
+      #
+      # @return [Object]
+      #
+      # @api private
+      def self.optimize_operand(operand)
+        operand.respond_to?(:optimize) ? operand.optimize : operand
+      end
+
+      # Optimize the summarizers
+      #
+      # @param [Hash{Attribute => Function}] functions
+      #
+      # @return [Hash{Attribute => Function}]
+      #
+      # @api private
+      def self.optimize_functions(functions)
+        optimized = {}
+        functions.each do |attribute, function|
+          optimized[attribute] = optimize_operand(function)
+        end
+        optimized.freeze
+      end
+
+      # Utility methods for Function optimization
+      module Util
+
+        # Test if the operand is a constant
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        def self.constant?(operand)
+          ! (operand.nil? || operand.respond_to?(:call))
+        end
+
+        # Test if the operand is an attribute
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        def self.attribute?(operand)
+          operand.kind_of?(Attribute)
+        end
+
+        # Return the minimum value for the operand
+        #
+        # @return [Object]
+        #
+        # @api private
+        def self.min(operand)
+          case operand
+          when Attribute::String  then operand.min_length
+          when Attribute::Numeric then operand.range.first
+          else
+            operand
+          end
+        end
+
+        # Return the maximum value for the operand
+        #
+        # @return [Object]
+        #
+        # @api private
+        def self.max(operand)
+          case operand
+          when Attribute::String  then operand.max_length
+          when Attribute::Numeric then operand.range.last
+          else
+            operand
+          end
+        end
+
+      end # module Util
+    end # module Function
+  end # class Optimizer
+end # module Axiom

data/lib/axiom/optimizer/function/binary.rb

@@ -0,0 +1,124 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Function
+
+      # Mixin for optimizations to Binary functions
+      module Binary
+
+        # The optimized left operand
+        #
+        # @return [Object]
+        #
+        # @api private
+        attr_reader :left
+
+        # The optimized right operand
+        #
+        # @return [Object]
+        #
+        # @api private
+        attr_reader :right
+
+        # Initialize an Predicate optimizer
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(*)
+          super
+          @left  = optimize_left
+          @right = optimize_right
+        end
+
+      private
+
+        # Optimize the left operand
+        #
+        # @return [Object]
+        #
+        # @api private
+        def optimize_left
+          Function.optimize_operand(operation.left)
+        end
+
+        # Optimize the right operand
+        #
+        # @return [Object]
+        #
+        # @api private
+        def optimize_right
+          Function.optimize_operand(operation.right)
+        end
+
+        # Optimize when the operands are constants
+        module ConstantOperands
+
+          # Test if the operands are constants
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            util = Util
+            util.constant?(left) && util.constant?(right)
+          end
+
+          # Evaluate the operands and return the constant
+          #
+          # @return [Object]
+          #
+          # @api private
+          def optimize
+            operation.class.call(left, right)
+          end
+
+        end # module ConstantOperands
+
+        # Optimize when the operand is unoptimized
+        module UnoptimizedOperands
+
+          # Test if the operands are unoptimized
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            left_optimizable? || right_optimizable?
+          end
+
+          # Return a Binary connective with optimized operands
+          #
+          # @return [Binary]
+          #
+          # @api private
+          def optimize
+            operation.class.new(left, right)
+          end
+
+        private
+
+          # Test if the left operand is optimizable
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def left_optimizable?
+            ! left.equal?(operation.left)
+          end
+
+          # Test if the right operand is optimizable
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def right_optimizable?
+            ! right.equal?(operation.right)
+          end
+
+        end # module UnoptimizedOperands
+      end # class Binary
+    end # module Function
+  end # class Optimizer
+end # module Axiom

data/lib/axiom/optimizer/function/connective/binary.rb

@@ -0,0 +1,245 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Function
+      module Connective
+
+        # Abstract base class representing Binary connective optimizations
+        class Binary < Optimizer
+          include Function::Binary
+
+        private
+
+          # Test if the operands are equality/inclusion predicates for the same attribute
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def equality_with_same_attributes?
+            left_equality?  &&
+            right_equality? &&
+            same_attribute? &&
+            constant_value?
+          end
+
+          # Test if the operands are inequality/exclusion predicates for the same attribute
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def inequality_with_same_attributes?
+            left_inequality?  &&
+            right_inequality? &&
+            same_attribute?   &&
+            constant_value?
+          end
+
+          # Test if the left and right predicates are for the same attribute
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def same_attribute?
+            left.left.equal?(right.left)
+          end
+
+          # Test if the left and right predicates match against constant values
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def constant_value?
+            util = Util
+            util.constant?(left.right) && util.constant?(right.right)
+          end
+
+          # Test if the left is an equality or inclusion
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def left_equality?
+            util = Axiom::Function::Predicate
+            left.kind_of?(util::Equality) || left.kind_of?(util::Inclusion)
+          end
+
+          # Test if the right is an equality or inclusion
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def right_equality?
+            util = Axiom::Function::Predicate
+            right.kind_of?(util::Equality) || right.kind_of?(util::Inclusion)
+          end
+
+          # Test if the left is an inequality or exclusion
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def left_inequality?
+            util = Axiom::Function::Predicate
+            left.kind_of?(util::Inequality) || left.kind_of?(util::Exclusion)
+          end
+
+          # Test if the right is an inequality or exclusion
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def right_inequality?
+            util = Axiom::Function::Predicate
+            right.kind_of?(util::Inequality) || right.kind_of?(util::Exclusion)
+          end
+
+          # Test if the left is a tautology
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def left_tautology?
+            left.equal?(Axiom::Function::Proposition::Tautology.instance)
+          end
+
+          # Test if the right is a tautology
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def right_tautology?
+            right.equal?(Axiom::Function::Proposition::Tautology.instance)
+          end
+
+          # Test if the left is a contradiction
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def left_contradiction?
+            left.equal?(Axiom::Function::Proposition::Contradiction.instance)
+          end
+
+          # Test if the right is a contradiction
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def right_contradiction?
+            right.equal?(Axiom::Function::Proposition::Contradiction.instance)
+          end
+
+          # Test if the left and right
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def contradiction?
+            left.respond_to?(:inverse)  &&
+            right.respond_to?(:inverse) &&
+            left.inverse.eql?(right)
+          end
+
+          # Merge the right enumerables from the operands
+          #
+          # @return [Array]
+          #
+          # @api private
+          def merged_right_enumerables
+            [ left.right, right.right ].flatten
+          end
+
+          # Optimize when the operands are constants
+          class ConstantOperands < self
+            include Function::Binary::ConstantOperands
+
+            # A Connective with constant values is equivalent to a Proposition
+            #
+            # @return [Proposition]
+            #
+            # @api private
+            def optimize
+              Axiom::Function::Proposition.new(super)
+            end
+
+          end # class ConstantOperands
+
+          # Optimize when the operands are equal
+          class EqualOperands < self
+
+            # Test if the operands are equal
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left.eql?(right)
+            end
+
+            # A Binary connective with equal operands is equivalent to the left
+            #
+            # @return [Function]
+            #
+            # @api private
+            def optimize
+              left
+            end
+
+          end # class EqualOperands
+
+          # Optimize when the left operand is redundant
+          class RedundantLeft < self
+
+            # Test if the left operand is redundant
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operation.kind_of?(left.class) && right.eql?(left.right)
+            end
+
+            # A Binary connective with a redundant left operand is equivalent to the left
+            #
+            # @return [Function]
+            #
+            # @api private
+            def optimize
+              left
+            end
+
+          end # class RedundantLeft
+
+          # Optimize when the right operand is redundant
+          class RedundantRight < self
+
+            # Test if the right operand is redundant
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operation.kind_of?(right.class) && left.eql?(right.left)
+            end
+
+            # A Binary connective with a redundant right operand is equivalent to the right
+            #
+            # @return [Function]
+            #
+            # @api private
+            def optimize
+              right
+            end
+
+          end # class RedundantRight
+
+          # Optimize when the operands are unoptimized
+          class UnoptimizedOperands < self
+            include Function::Binary::UnoptimizedOperands
+          end # class UnoptimizedOperands
+        end # class Binary
+      end # module Connective
+    end # module Function
+  end # class Optimizer
+end # module Axiom