axiom-optimizer 0.1.0

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

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Function
+      class Predicate
+
+        # Abstract base class representing Equality optimizations
+        class Equality < self
+          include Comparable
+
+          # Optimize when the operand are a contradiction
+          class Contradiction < self
+            include Comparable::NeverEquivalent, Predicate::Contradiction
+          end # class Contradiction
+
+          # Optimize when the operand are a tautology
+          class Tautology < self
+            include Predicate::Tautology
+
+            # Test if the operands are a tautology
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left.equal?(right)
+            end
+
+          end # class Tautology
+
+          Axiom::Function::Predicate::Equality.optimizer = chain(
+            ConstantOperands,
+            Contradiction,
+            Tautology,
+            NormalizableOperands,
+            UnoptimizedOperands
+          )
+
+        end # class Equality
+      end # class Predicate
+    end # module Function
+  end # class Optimizer
+end # module Axiom

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

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Function
+      class Predicate
+
+        # Abstract base class representing Exclusion optimizations
+        class Exclusion < self
+          include Enumerable
+
+          # Optimize when the right operand is empty
+          class EmptyRight < self
+            include Enumerable::EmptyRight, Predicate::Tautology
+          end # class EmptyRight
+
+          # Optimize when the right operand has one entry
+          class OneRight < self
+            include Enumerable::OneRight
+
+            # An Exclusion with a single right operand is equivalent to an Inequality
+            #
+            # @return [Inequality]
+            #
+            # @api private
+            def optimize
+              left.ne(right.first)
+            end
+
+          end # class OneRight
+
+          Axiom::Function::Predicate::Exclusion.optimizer = chain(
+            ConstantOperands,
+            EmptyRight,
+            OneRight,
+            Enumerable::UnoptimizedOperands
+          )
+
+        end # class Exclusion
+      end # class Predicate
+    end # module Function
+  end # class Optimizer
+end # module Axiom

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

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Function
+      class Predicate
+
+        # Abstract base class representing GreaterThan optimizations
+        class GreaterThan < self
+          include Comparable
+
+          # Optimize when the operands are a contradiction
+          class Contradiction < self
+            include Predicate::Contradiction
+
+            # Test if the operands are a contradiction
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left.equal?(right) ||
+              GreaterThanOrEqualTo::Contradiction.new(operation).optimizable?
+            end
+
+          end # class Contradiction
+
+          # Optimize when the operands are a tautology
+          class Tautology < self
+            include Predicate::Tautology
+
+            # Test if the operands are a tautology
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operation.class.call(Util.min(left), Util.max(right))
+            end
+
+          end # class Tautology
+
+          Axiom::Function::Predicate::GreaterThan.optimizer = chain(
+            ConstantOperands,
+            Contradiction,
+            Tautology,
+            NormalizableOperands,
+            UnoptimizedOperands
+          )
+
+        end # class GreaterThan
+      end # class Predicate
+    end # module Function
+  end # class Optimizer
+end # module Axiom

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

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Function
+      class Predicate
+
+        # Abstract base class representing GreaterThanOrEqualTo optimizations
+        class GreaterThanOrEqualTo < self
+          include Comparable
+
+          # Optimize when the operands are a contradiction
+          class Contradiction < self
+            include Comparable::NeverComparable, Predicate::Contradiction
+
+            # Test if the operands are a contradiction
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              super || LessThan::Tautology.new(operation.inverse).optimizable?
+            end
+
+          end # class Contradiction
+
+          # Optimize when the operands are a tautology
+          class Tautology < self
+            include Predicate::Tautology
+
+            # Test if the operands are a tautology
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              GreaterThan::Tautology.new(operation).optimizable? ||
+              Equality::Tautology.new(operation).optimizable?
+            end
+
+          end # class Tautology
+
+          Axiom::Function::Predicate::GreaterThanOrEqualTo.optimizer = chain(
+            ConstantOperands,
+            Contradiction,
+            Tautology,
+            NormalizableOperands,
+            UnoptimizedOperands
+          )
+
+        end # class GreaterThanOrEqualTo
+      end # class Predicate
+    end # module Function
+  end # class Optimizer
+end # module Axiom

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

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Function
+      class Predicate
+
+        # Abstract base class representing Inclusion optimizations
+        class Inclusion < self
+          include Enumerable
+
+          # Optimize when the right operand is empty
+          class EmptyRight < self
+            include Enumerable::EmptyRight, Predicate::Contradiction
+          end # class EmptyRight
+
+          # Optimize when the right operand has one entry
+          class OneRight < self
+            include Enumerable::OneRight
+
+            # An Inclusion with a single right operand is equivalent to an Equality
+            #
+            # @return [Equality]
+            #
+            # @api private
+            def optimize
+              left.eq(right.first)
+            end
+
+          end # class OneRight
+
+          Axiom::Function::Predicate::Inclusion.optimizer = chain(
+            ConstantOperands,
+            EmptyRight,
+            OneRight,
+            Enumerable::UnoptimizedOperands
+          )
+
+        end # class Inclusion
+      end # class Predicate
+    end # module Function
+  end # class Optimizer
+end # module Axiom

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

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Function
+      class Predicate
+
+        # Abstract base class representing Inequality optimizations
+        class Inequality < self
+          include Comparable
+
+          # Optimize when the operand are a contradiction
+          class Contradiction < self
+            include Predicate::Contradiction
+
+            # Test if the operands are a contradiction
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left.equal?(right)
+            end
+
+          end # class Contradiction
+
+          # Optimize when the operand are a tautology
+          class Tautology < self
+            include Comparable::NeverEquivalent, Predicate::Tautology
+          end # class Tautology
+
+          Axiom::Function::Predicate::Inequality.optimizer = chain(
+            ConstantOperands,
+            Contradiction,
+            Tautology,
+            NormalizableOperands,
+            UnoptimizedOperands
+          )
+
+        end # class Inequality
+      end # class Predicate
+    end # module Function
+  end # class Optimizer
+end # module Axiom

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

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Function
+      class Predicate
+
+        # Abstract base class representing LessThan optimizations
+        class LessThan < self
+          include Comparable
+
+          # Optimize when the operands are a contradiction
+          class Contradiction < self
+            include Predicate::Contradiction
+
+            # Test if the operands are a contradiction
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left.equal?(right) ||
+              LessThanOrEqualTo::Contradiction.new(operation).optimizable?
+            end
+
+          end # class Contradiction
+
+          # Optimize when the operands are a tautology
+          class Tautology < self
+            include Predicate::Tautology
+
+            # Test if the operands are a tautology
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operation.class.call(Util.max(left), Util.min(right))
+            end
+
+          end # class Tautology
+
+          Axiom::Function::Predicate::LessThan.optimizer = chain(
+            ConstantOperands,
+            Contradiction,
+            Tautology,
+            NormalizableOperands,
+            UnoptimizedOperands
+          )
+
+        end # class LessThan
+      end # class Predicate
+    end # module Function
+  end # class Optimizer
+end # module Axiom

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

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Function
+      class Predicate
+
+        # Abstract base class representing LessThanOrEqualTo optimizations
+        class LessThanOrEqualTo < self
+          include Comparable
+
+          # Optimize when the operands are a contradiction
+          class Contradiction < self
+            include Comparable::NeverComparable, Predicate::Contradiction
+
+            # Test if the operands are a contradiction
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              super || GreaterThan::Tautology.new(operation.inverse).optimizable?
+            end
+
+          end # class Contradiction
+
+          # Optimize when the operands are a tautology
+          class Tautology < self
+            include Predicate::Tautology
+
+            # Test if the operands are a tautology
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              LessThan::Tautology.new(operation).optimizable? ||
+              Equality::Tautology.new(operation).optimizable?
+            end
+
+          end # class Tautology
+
+          Axiom::Function::Predicate::LessThanOrEqualTo.optimizer = chain(
+            ConstantOperands,
+            Contradiction,
+            Tautology,
+            NormalizableOperands,
+            UnoptimizedOperands
+          )
+
+        end # class LessThanOrEqualTo
+      end # class Predicate
+    end # module Function
+  end # class Optimizer
+end # module Axiom

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

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

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

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