veritas-optimizer 0.0.3 → 0.0.4

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

@@ -0,0 +1,124 @@
+# encoding: utf-8
+
+module Veritas
+  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 Veritas

data/lib/veritas/optimizer/{logic → function}/connective/binary.rb

@@ -2,68 +2,24 @@
 
 module Veritas
   class Optimizer
-    module Logic
+    module Function
       module Connective
 
         # Abstract base class representing Binary connective optimizations
         class Binary < Optimizer
-
-          # The optimized left operand
-          #
-          # @return [Expression]
-          #
-          # @api private
-          attr_reader :left
-
-          # The optimized right operand
-          #
-          # @return [Expression]
-          #
-          # @api private
-          attr_reader :right
-
-          # Initialize an Binary optimizer
-          #
-          # @return [undefined]
-          #
-          # @api private
-          def initialize(*)
-            super
-            @left  = optimize_left
-            @right = optimize_right
-          end
+          include Function::Binary
 
         private
 
-          # Optimize the left operand
-          #
-          # @return [Expression]
-          #
-          # @api private
-          def optimize_left
-            # TODO: move Predicate.optimize_operand to a better location
-            Predicate.optimize_operand(operation.left)
-          end
-
-          # Optimize the right operand
-          #
-          # @return [Expression]
-          #
-          # @api private
-          def optimize_right
-            # TODO: move Predicate.optimize_operand to a better location
-            Predicate.optimize_operand(operation.right)
-          end
-
           # Test if the operands are equality predicates for the same attribute
           #
           # @return [Boolean]
           #
           # @api private
           def equality_with_same_attributes?
-            left.kind_of?(Veritas::Logic::Predicate::Equality)  &&
-            right.kind_of?(Veritas::Logic::Predicate::Equality) &&
-            same_attribute?                                     &&
+            left.kind_of?(Veritas::Function::Predicate::Equality)  &&
+            right.kind_of?(Veritas::Function::Predicate::Equality) &&
+            same_attribute?                                        &&
             constant_value?
           end
 
@@ -73,9 +29,9 @@ module Veritas
           #
           # @api private
           def inequality_with_same_attributes?
-            left.kind_of?(Veritas::Logic::Predicate::Inequality)  &&
-            right.kind_of?(Veritas::Logic::Predicate::Inequality) &&
-            same_attribute?                                       &&
+            left.kind_of?(Veritas::Function::Predicate::Inequality)  &&
+            right.kind_of?(Veritas::Function::Predicate::Inequality) &&
+            same_attribute?                                          &&
             constant_value?
           end
 
@@ -94,7 +50,7 @@ module Veritas
           #
           # @api private
           def constant_value?
-            util = Predicate::Util
+            util = Util
             util.constant?(left.right) && util.constant?(right.right)
           end
 
@@ -104,7 +60,7 @@ module Veritas
           #
           # @api private
           def left_tautology?
-            left.equal?(Veritas::Logic::Proposition::Tautology.instance)
+            left.equal?(Veritas::Function::Proposition::Tautology.instance)
           end
 
           # Test if the right is a tautology
@@ -113,7 +69,7 @@ module Veritas
           #
           # @api private
           def right_tautology?
-            right.equal?(Veritas::Logic::Proposition::Tautology.instance)
+            right.equal?(Veritas::Function::Proposition::Tautology.instance)
           end
 
           # Test if the left is a contradiction
@@ -122,7 +78,7 @@ module Veritas
           #
           # @api private
           def left_contradiction?
-            left.equal?(Veritas::Logic::Proposition::Contradiction.instance)
+            left.equal?(Veritas::Function::Proposition::Contradiction.instance)
           end
 
           # Test if the right is a contradiction
@@ -131,9 +87,37 @@ module Veritas
           #
           # @api private
           def right_contradiction?
-            right.equal?(Veritas::Logic::Proposition::Contradiction.instance)
+            right.equal?(Veritas::Function::Proposition::Contradiction.instance)
+          end
+
+          # Test if the left and right
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def contradiction?
+            left  = self.left
+            right = self.right
+            left.respond_to?(:inverse)  &&
+            right.respond_to?(:inverse) &&
+            left.inverse.eql?(right)
           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
+              Veritas::Function::Proposition.new(super)
+            end
+
+          end # class ConstantOperands
+
           # Optimize when the operands are equal
           class EqualOperands < self
 
@@ -148,7 +132,7 @@ module Veritas
 
             # A Binary connective with equal operands is equivalent to the left
             #
-            # @return [Expression]
+            # @return [Function]
             #
             # @api private
             def optimize
@@ -172,7 +156,7 @@ module Veritas
 
             # A Binary connective with a redundant left operand is equivalent to the left
             #
-            # @return [Expression]
+            # @return [Function]
             #
             # @api private
             def optimize
@@ -196,7 +180,7 @@ module Veritas
 
             # A Binary connective with a redundant right operand is equivalent to the right
             #
-            # @return [Expression]
+            # @return [Function]
             #
             # @api private
             def optimize
@@ -206,49 +190,11 @@ module Veritas
           end # class RedundantRightOperand
 
           # Optimize when the operands are unoptimized
-          class UnoptimizedOperand < self
-
-            # 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 # class UnoptimizedOperand
+          class UnoptimizedOperands < self
+            include Function::Binary::UnoptimizedOperands
+          end # class UnoptimizedOperands
         end # class Binary
       end # module Connective
-    end # module Logic
+    end # module Function
   end # class Optimizer
 end # module Veritas

data/lib/veritas/optimizer/{logic → function}/connective/conjunction.rb

@@ -2,7 +2,7 @@
 
 module Veritas
   class Optimizer
-    module Logic
+    module Function
       module Connective
 
         # Abstract base class representing Conjunction optimizations
@@ -22,7 +22,7 @@ module Veritas
 
             # A Conjunction with a tautology left operand is equivalent to the right
             #
-            # @return [Expression]
+            # @return [Function]
             #
             # @api private
             def optimize
@@ -45,7 +45,7 @@ module Veritas
 
             # A Conjunction with a tautology right operand is equivalent to the left
             #
-            # @return [Expression]
+            # @return [Function]
             #
             # @api private
             def optimize
@@ -73,7 +73,7 @@ module Veritas
             # @api private
             def optimize
               left = self.left
-              Veritas::Logic::Predicate::Exclusion.new(left.left, [ left.right, right.right ]).optimize
+              Veritas::Function::Predicate::Exclusion.new(left.left, [ left.right, right.right ]).optimize
             end
 
           end # class OptimizableToExclusion
@@ -87,10 +87,10 @@ module Veritas
             #
             # @api private
             def optimizable?
-              left_contradiction?                    ||
-              right_contradiction?                   ||
+              left_contradiction?            ||
+              right_contradiction?           ||
               equality_with_same_attributes? ||
-              left.inverse.eql?(right)
+              contradiction?
             end
 
             # Return a contradiction
@@ -99,12 +99,13 @@ module Veritas
             #
             # @api private
             def optimize
-              Veritas::Logic::Proposition::Contradiction.instance
+              Veritas::Function::Proposition::Contradiction.instance
             end
 
           end # class Contradiction
 
-          Veritas::Logic::Connective::Conjunction.optimizer = chain(
+          Veritas::Function::Connective::Conjunction.optimizer = chain(
+            ConstantOperands,
             LeftOperandTautology,
             RightOperandTautology,
             OptimizableToExclusion,
@@ -112,11 +113,11 @@ module Veritas
             RedundantLeftOperand,
             RedundantRightOperand,
             Contradiction,
-            UnoptimizedOperand
+            UnoptimizedOperands
           )
 
         end # class Conjunction
       end # module Connective
-    end # module Logic
+    end # module Function
   end # class Optimizer
 end # module Veritas

data/lib/veritas/optimizer/{logic → function}/connective/disjunction.rb

@@ -2,7 +2,7 @@
 
 module Veritas
   class Optimizer
-    module Logic
+    module Function
       module Connective
 
         # Abstract base class representing Disjunction optimizations
@@ -22,7 +22,7 @@ module Veritas
 
             # A Disjunction with a contradiction left operand is equivalent to the right
             #
-            # @return [Expression]
+            # @return [Function]
             #
             # @api private
             def optimize
@@ -45,7 +45,7 @@ module Veritas
 
             # A Disjunction with a contradiction right operand is equivalent to the left
             #
-            # @return [Expression]
+            # @return [Function]
             #
             # @api private
             def optimize
@@ -73,38 +73,39 @@ module Veritas
             # @api private
             def optimize
               left = self.left
-              Veritas::Logic::Predicate::Inclusion.new(left.left, [ left.right, right.right ]).optimize
+              Veritas::Function::Predicate::Inclusion.new(left.left, [ left.right, right.right ]).optimize
             end
 
           end # class OptimizableToInclusion
 
-          # Optimize when the operands are a tuatology
+          # Optimize when the operands are a tautology
           class Tautology < self
 
-            # Test if the operands are a tuatology
+            # Test if the operands are a tautology
             #
             # @return [Boolean]
             #
             # @api private
             def optimizable?
-              left_tautology?                       ||
-              right_tautology?                      ||
+              left_tautology?                  ||
+              right_tautology?                 ||
               inequality_with_same_attributes? ||
-              left.inverse.eql?(right)
+              contradiction?
             end
 
-            # Return a tuatology
+            # Return a tautology
             #
             # @return [Tautology]
             #
             # @api private
             def optimize
-              Veritas::Logic::Proposition::Tautology.instance
+              Veritas::Function::Proposition::Tautology.instance
             end
 
           end # class Tautology
 
-          Veritas::Logic::Connective::Disjunction.optimizer = chain(
+          Veritas::Function::Connective::Disjunction.optimizer = chain(
+            ConstantOperands,
             ContradictionLeftOperand,
             ContradictionRightOperand,
             OptimizableToInclusion,
@@ -112,11 +113,11 @@ module Veritas
             RedundantLeftOperand,
             RedundantRightOperand,
             Tautology,
-            UnoptimizedOperand
+            UnoptimizedOperands
           )
 
         end # class Disjunction
       end # module Connective
-    end # module Logic
+    end # module Function
   end # class Optimizer
 end # module Veritas

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

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+module Veritas
+  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
+              Veritas::Function::Proposition.new(super)
+            end
+
+          end # class ConstantOperand
+
+          # Optimize when the operand is unoptimized
+          class UnoptimizedOperand < self
+            include Function::Unary::UnoptimizedOperand
+          end # class UnoptimizedOperand
+
+          Veritas::Function::Connective::Negation.optimizer = chain(
+            ConstantOperand,
+            InvertibleOperand,
+            UnoptimizedOperand
+          )
+
+        end # class Negation
+      end # module Connective
+    end # module Function
+  end # class Optimizer
+end # module Veritas

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

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

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

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

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

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

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

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

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

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