axiom-optimizer 0.1.0

data/lib/axiom/optimizer/function/numeric/multiplication.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Function
+      class Numeric
+
+        # Abstract base class representing Multiplication optimizations
+        class Multiplication < self
+
+          Axiom::Function::Numeric::Multiplication.optimizer = chain(
+            ConstantOperands,
+            UnoptimizedOperands
+          )
+
+        end # class Multiplication
+      end # class Numeric
+    end # module Function
+  end # class Optimizer
+end # module Axiom

data/lib/axiom/optimizer/function/numeric/square_root.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Function
+      class Numeric
+
+        # Abstract base class representing SquareRoot optimizations
+        class SquareRoot < self
+
+          Axiom::Function::Numeric::SquareRoot.optimizer = chain(
+            ConstantOperand,
+            UnoptimizedOperand
+          )
+
+        end # class SquareRoot
+      end # class Numeric
+    end # module Function
+  end # class Optimizer
+end # module Axiom

data/lib/axiom/optimizer/function/numeric/subtraction.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Function
+      class Numeric
+
+        # Abstract base class representing Subtraction optimizations
+        class Subtraction < self
+
+          Axiom::Function::Numeric::Subtraction.optimizer = chain(
+            ConstantOperands,
+            UnoptimizedOperands
+          )
+
+        end # class Subtraction
+      end # class Numeric
+    end # module Function
+  end # class Optimizer
+end # module Axiom

data/lib/axiom/optimizer/function/numeric/unary_minus.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Function
+      class Numeric
+
+        # Abstract base class representing UnaryMinus optimizations
+        class UnaryMinus < self
+
+          Axiom::Function::Numeric::UnaryMinus.optimizer = chain(
+            ConstantOperand,
+            UnoptimizedOperand
+          )
+
+        end # class UnaryMinus
+      end # class Numeric
+    end # module Function
+  end # class Optimizer
+end # module Axiom

data/lib/axiom/optimizer/function/numeric/unary_plus.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Function
+      class Numeric
+
+        # Abstract base class representing UnaryPlus optimizations
+        class UnaryPlus < self
+
+          Axiom::Function::Numeric::UnaryPlus.optimizer = chain(
+            ConstantOperand,
+            UnoptimizedOperand
+          )
+
+        end # class UnaryPlus
+      end # class Numeric
+    end # module Function
+  end # class Optimizer
+end # module Axiom

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

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Function
+
+      # Abstract base class representing Predicate optimizations
+      class Predicate < Optimizer
+        include AbstractType, Binary
+
+        # Optimize when the operands are constants
+        class ConstantOperands < self
+          include Binary::ConstantOperands
+
+          # A Predicate 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 unoptimized
+        class UnoptimizedOperands < self
+          include Binary::UnoptimizedOperands
+        end # class UnoptimizedOperands
+
+        # Optimize when the operands are a contradiction
+        module Contradiction
+
+          # Return a contradiction
+          #
+          # @return [Contradiction]
+          #
+          # @api private
+          def optimize
+            Axiom::Function::Proposition::Contradiction.instance
+          end
+
+        end # module Contradiction
+
+        # Optimize when the operands are a tautology
+        module Tautology
+
+          # Return a tautology
+          #
+          # @return [Tautology]
+          #
+          # @api private
+          def optimize
+            Axiom::Function::Proposition::Tautology.instance
+          end
+
+        end # module Tautology
+      end # class Predicate
+    end # module Function
+  end # class Optimizer
+end # module Axiom

data/lib/axiom/optimizer/function/predicate/comparable.rb

@@ -0,0 +1,144 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Function
+      class Predicate
+
+        # Abstract base class representing Comparable predicate optimizations
+        module Comparable
+
+          # Optimize when the operands can be normalized
+          class NormalizableOperands < Predicate
+
+            # Test if the operands can be normalized
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              util = Util
+              util.constant?(left) && util.attribute?(right)
+            end
+
+            # Normalize the predicate by reversing the operands
+            #
+            # @return [Predicate]
+            #
+            # @api private
+            def optimize
+              operation.class.reverse.new(right, left)
+            end
+
+          end # class NormalizableOperands
+
+          # Optimize when the operands will never be equivalent
+          module NeverEquivalent
+
+            # Test if the operands will never be equivalent
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              util = Util
+              if    nil_operand?          then true
+              elsif util.constant?(left)  then left_invalid_constant?
+              elsif util.constant?(right) then right_invalid_constant?
+              else
+                ! joinable?
+              end
+            end
+
+          private
+
+            # Test if an operand is nil
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def nil_operand?
+              left.nil? || right.nil?
+            end
+
+            # Test if the left operand is an invalid constant
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def left_invalid_constant?
+              ! right.valid_value?(left)
+            end
+
+            # Test if the right operand is an invalid constant
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def right_invalid_constant?
+              ! left.valid_value?(right)
+            end
+
+            # Test if the left and right operand are joinable
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def joinable?
+              left.eql?(right.rename(left.name))
+            end
+
+          end # module NeverEquivalent
+
+          # Optimize when the operands will never be comparable
+          module NeverComparable
+
+            # Test if the operands will never be comparable
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              util = Util
+              if    util.constant?(left)  then left_invalid_constant?
+              elsif util.constant?(right) then right_invalid_constant?
+              else
+                ! comparable?
+              end
+            end
+
+          private
+
+            # Test if the left operand is an invalid constant
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def left_invalid_constant?
+              ! right.valid_primitive?(left)
+            end
+
+            # Test if the right operand is an invalid constant
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def right_invalid_constant?
+              ! left.valid_primitive?(right)
+            end
+
+            # Test if the left and right operand are comparable
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def comparable?
+              left.class <=> right.class
+            end
+
+          end # module NeverComparable
+        end # module Comparable
+      end # class Predicate
+    end # module Function
+  end # class Optimizer
+end # module Axiom

data/lib/axiom/optimizer/function/predicate/enumerable.rb

@@ -0,0 +1,138 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Function
+      class Predicate
+
+        # Abstract base class representing Enumerable predicate optimizations
+        module Enumerable
+
+          # Return a value to sort the obejct with
+          #
+          # @param [Object] object
+          #
+          # @return [Object]
+          #
+          # @api private
+          def self.sort_by_value(object)
+            case object
+            when TrueClass  then 1
+            when FalseClass then 0
+            else
+              object
+            end
+          end
+
+        private
+
+          # Optimize the right operand
+          #
+          # @return [Object]
+          #
+          # @api private
+          def optimize_right
+            right = operation.right
+
+            if right.respond_to?(:to_inclusive)
+              optimize_right_range
+            elsif right.respond_to?(:select)
+              optimize_right_enumerable
+            else
+              right
+            end
+          end
+
+          # Optimize the right range operand
+          #
+          # @return [Range]
+          #
+          # @api private
+          def optimize_right_range
+            right = operation.right
+            return unless left.respond_to?(:range)
+            right.to_inclusive if right.overlaps?(left.range)
+          end
+
+          # Optimize the right enumerable operand
+          #
+          # @return [Enumerable]
+          #
+          # @api private
+          def optimize_right_enumerable
+            enumerable = normalized_right_enumerable
+            right      = operation.right
+
+            right.eql?(enumerable) ? right : enumerable
+          end
+
+          # Normalize the right enumerable to only include unique, sorted, valid values
+          #
+          # @return [Enumerable]
+          #
+          # @api private
+          def normalized_right_enumerable
+            enumerable = operation.right.select { |value| left.valid_value?(value) }
+            enumerable.uniq!
+            enumerable.sort_by! { |value| Enumerable.sort_by_value(value) }
+          end
+
+          # Optimize when the right operand is empty
+          module EmptyRight
+            include Enumerable
+
+            # Test if the right operand is empty
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              right_nil? || right_none?
+            end
+
+          private
+
+            # Test if the right operand is nil
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def right_nil?
+              right.nil?
+            end
+
+            # Test if the right operand has no entries
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def right_none?
+              right.none? { true }
+            end
+
+          end # module EmptyRight
+
+          # Optimize when the right operand has one entry
+          module OneRight
+            include Enumerable
+
+            # Test if the right operand has one entry
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              right.one? { true }
+            end
+
+          end # module OneRight
+
+          # Optimize when the operands are unoptimized
+          class UnoptimizedOperands < Predicate::UnoptimizedOperands
+            include Enumerable, Function::Binary::UnoptimizedOperands
+          end # class UnoptimizedOperands
+        end # module Enumerable
+      end # class Predicate
+    end # module Function
+  end # class Optimizer
+end # module Axiom