axiom-optimizer 0.1.0

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

@@ -0,0 +1,122 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Function
+      module Connective
+
+        # Abstract base class representing Conjunction optimizations
+        class Conjunction < Binary
+
+          # Optimize when the left operand is a tautology
+          class TautologyLeft < self
+
+            # Test if the left operand is a tautology
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left_tautology?
+            end
+
+            # A Conjunction with a tautology left operand is equivalent to the right
+            #
+            # @return [Function]
+            #
+            # @api private
+            def optimize
+              right
+            end
+
+          end # class TautologyLeft
+
+          # Optimize when the right operand is a tautology
+          class TautologyRight < self
+
+            # Test if the right operand is a tautology
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              right_tautology?
+            end
+
+            # A Conjunction with a tautology right operand is equivalent to the left
+            #
+            # @return [Function]
+            #
+            # @api private
+            def optimize
+              left
+            end
+
+          end # class TautologyRight
+
+          # Optimize when the operands are inequality predicates for the same attribute
+          class OptimizableToExclusion < self
+
+            # Test if the operands are inequality predicates for the same attribute
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              inequality_with_same_attributes?
+            end
+
+            # Return an Exclusion for an attribute against a set of values
+            #
+            # @return [Exclusion]
+            #
+            # @api private
+            def optimize
+              left.left.exclude(merged_right_enumerables).optimize
+            end
+
+          end # class OptimizableToExclusion
+
+          # Optimize when the operands are a contradiction
+          class Contradiction < self
+
+            # Test if the operands are a contradiction
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left_contradiction?            ||
+              right_contradiction?           ||
+              equality_with_same_attributes? ||
+              contradiction?
+            end
+
+            # Return a contradiction
+            #
+            # @return [Contradiction]
+            #
+            # @api private
+            def optimize
+              Axiom::Function::Proposition::Contradiction.instance
+            end
+
+          end # class Contradiction
+
+          Axiom::Function::Connective::Conjunction.optimizer = chain(
+            ConstantOperands,
+            TautologyLeft,
+            TautologyRight,
+            OptimizableToExclusion,
+            EqualOperands,
+            RedundantLeft,
+            RedundantRight,
+            Contradiction,
+            UnoptimizedOperands
+          )
+
+        end # class Conjunction
+      end # module Connective
+    end # module Function
+  end # class Optimizer
+end # module Axiom

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

@@ -0,0 +1,122 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Function
+      module Connective
+
+        # Abstract base class representing Disjunction optimizations
+        class Disjunction < Binary
+
+          # Optimize when the left operand is a contradiction
+          class ContradictionLeft < self
+
+            # Test if the left operand is a contradiction
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left_contradiction?
+            end
+
+            # A Disjunction with a contradiction left operand is equivalent to the right
+            #
+            # @return [Function]
+            #
+            # @api private
+            def optimize
+              right
+            end
+
+          end # class ContradictionLeft
+
+          # Optimize when the right operand is a contradiction
+          class ContradictionRight < self
+
+            # Test if the right operand is a contradiction
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              right_contradiction?
+            end
+
+            # A Disjunction with a contradiction right operand is equivalent to the left
+            #
+            # @return [Function]
+            #
+            # @api private
+            def optimize
+              left
+            end
+
+          end # class ContradictionRight
+
+          # Optimize when the operands are equality predicates for the same attribute
+          class OptimizableToInclusion < self
+
+            # Test if the operands are equality predicates for the same attribute
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              equality_with_same_attributes?
+            end
+
+            # Return an Inclusion for an attribute having a set of values
+            #
+            # @return [Inclusion]
+            #
+            # @api private
+            def optimize
+              left.left.include(merged_right_enumerables).optimize
+            end
+
+          end # class OptimizableToInclusion
+
+          # Optimize when the operands are a tautology
+          class Tautology < self
+
+            # Test if the operands are a tautology
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left_tautology?                  ||
+              right_tautology?                 ||
+              inequality_with_same_attributes? ||
+              contradiction?
+            end
+
+            # Return a tautology
+            #
+            # @return [Tautology]
+            #
+            # @api private
+            def optimize
+              Axiom::Function::Proposition::Tautology.instance
+            end
+
+          end # class Tautology
+
+          Axiom::Function::Connective::Disjunction.optimizer = chain(
+            ConstantOperands,
+            ContradictionLeft,
+            ContradictionRight,
+            OptimizableToInclusion,
+            EqualOperands,
+            RedundantLeft,
+            RedundantRight,
+            Tautology,
+            UnoptimizedOperands
+          )
+
+        end # class Disjunction
+      end # module Connective
+    end # module Function
+  end # class Optimizer
+end # module Axiom

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

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Function
+      module Connective
+
+        # Abstract base class representing Negation optimizations
+        class Negation < Optimizer
+          include Unary
+
+          # Optimize when the operand can be inverted
+          class InvertibleOperand < self
+
+            # Test if the operand can be inverted
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operand.respond_to?(:inverse)
+            end
+
+            # A Negation of an Function is equivalent to the inverted Function
+            #
+            # @return [Function]
+            #
+            # @api private
+            def optimize
+              operand.inverse
+            end
+
+          end # class InvertibleOperand
+
+          # Optimize when the operand is constant
+          class ConstantOperand < self
+            include Unary::ConstantOperand
+
+            # A Negation with constant values is equivalent to a Proposition
+            #
+            # @return [Proposition]
+            #
+            # @api private
+            def optimize
+              Axiom::Function::Proposition.new(super)
+            end
+
+          end # class ConstantOperand
+
+          # Optimize when the operand is unoptimized
+          class UnoptimizedOperand < self
+            include Function::Unary::UnoptimizedOperand
+          end # class UnoptimizedOperand
+
+          Axiom::Function::Connective::Negation.optimizer = chain(
+            ConstantOperand,
+            InvertibleOperand,
+            UnoptimizedOperand
+          )
+
+        end # class Negation
+      end # module Connective
+    end # module Function
+  end # class Optimizer
+end # module Axiom

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

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Function
+
+      # Abstract base class representing Numeric optimizations
+      class Numeric < Optimizer
+        include AbstractType
+
+        # Optimize when the operand is constant
+        class ConstantOperand < self
+          include Unary::ConstantOperand, Unary
+        end # class ConstantOperand
+
+        # Optimize when the operands are constants
+        class ConstantOperands < self
+          include Binary::ConstantOperands, Binary
+        end # class ConstantOperands
+
+        # Optimize when the operand is unoptimized
+        class UnoptimizedOperand < self
+          include Unary::UnoptimizedOperand, Unary
+        end # class UnoptimizedOperand
+
+        # Optimize when the operand is unoptimized
+        class UnoptimizedOperands < self
+          include Binary::UnoptimizedOperands, Binary
+        end # class UnoptimizedOperands
+
+      end # class Numeric
+    end # module Function
+  end # class Optimizer
+end # module Axiom

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

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

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

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

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

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

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

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

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

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