veritas-optimizer 0.0.3 → 0.0.4

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Function
+
+      # Abstract base class representing Numeric optimizations
+      class Numeric < Optimizer
+        include AbstractClass
+
+        # 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 Veritas

data/lib/veritas/optimizer/{logic → function}/predicate/comparable.rb

@@ -2,7 +2,7 @@
 
 module Veritas
   class Optimizer
-    module Logic
+    module Function
       class Predicate
 
         # Abstract base class representing Comparable predicate optimizations
@@ -75,7 +75,8 @@ module Veritas
             #
             # @api private
             def not_joinable?
-              !left.joinable?(right)
+              left = self.left
+              !(left.respond_to?(:joinable?) && left.joinable?(right))
             end
 
           end # module NeverEquivalent
@@ -123,12 +124,13 @@ module Veritas
             #
             # @api private
             def not_comparable?
-              !left.comparable?(right)
+              left = self.left
+              !(left.respond_to?(:comparable?) && left.comparable?(right))
             end
 
           end # module NeverComparable
         end # module Comparable
       end # class Predicate
-    end # module Logic
+    end # module Function
   end # class Optimizer
 end # module Veritas

data/lib/veritas/optimizer/{logic → function}/predicate/enumerable.rb

@@ -2,12 +2,28 @@
 
 module Veritas
   class Optimizer
-    module Logic
+    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
@@ -33,7 +49,9 @@ module Veritas
           #
           # @api private
           def optimize_right_range
+            left  = self.left
             right = operation.right
+            return unless left.respond_to?(:range)
             right.to_inclusive if right.overlaps?(left.range)
           end
 
@@ -56,9 +74,8 @@ module Veritas
           # @api private
           def normalized_right_enumerable
             enumerable = operation.right.select { |value| left.valid_value?(value) }
-            enumerable.sort!
             enumerable.uniq!
-            enumerable
+            enumerable.sort_by! { |value| Enumerable.sort_by_value(value) }
           end
 
           # Optimize when the right operand is empty
@@ -112,30 +129,11 @@ module Veritas
           end # module OneRightOperand
 
           # Optimize when the operands are unoptimized
-          class UnoptimizedOperand < Predicate
-            include Enumerable
-
-            # Test if the operands are unoptimized
-            #
-            # @return [Boolean]
-            #
-            # @api private
-            def optimizable?
-              !right.equal?(operation.right)
-            end
-
-            # Return a Enumerable predicate with optimized operands
-            #
-            # @return [Binary]
-            #
-            # @api private
-            def optimize
-              operation.class.new(left, right)
-            end
-
-          end # class UnoptimizedOperand
+          class UnoptimizedOperands < Predicate::UnoptimizedOperands
+            include Enumerable, Function::Binary::UnoptimizedOperands
+          end # class UnoptimizedOperands
         end # module Enumerable
       end # class Predicate
-    end # module Logic
+    end # module Function
   end # class Optimizer
 end # module Veritas

data/lib/veritas/optimizer/{logic → function}/predicate/equality.rb

@@ -2,7 +2,7 @@
 
 module Veritas
   class Optimizer
-    module Logic
+    module Function
       class Predicate
 
         # Abstract base class representing Equality optimizations
@@ -11,8 +11,7 @@ module Veritas
 
           # Optimize when the operand are a contradiction
           class Contradiction < self
-            include Comparable::NeverEquivalent
-            include Predicate::Contradiction
+            include Comparable::NeverEquivalent, Predicate::Contradiction
           end # class Contradiction
 
           # Optimize when the operand are a tautology
@@ -30,15 +29,16 @@ module Veritas
 
           end # class Tautology
 
-          Veritas::Logic::Predicate::Equality.optimizer = chain(
+          Veritas::Function::Predicate::Equality.optimizer = chain(
             ConstantOperands,
             Contradiction,
             Tautology,
-            NormalizableOperands
+            NormalizableOperands,
+            UnoptimizedOperands
           )
 
         end # class Equality
       end # class Predicate
-    end # module Logic
+    end # module Function
   end # class Optimizer
 end # module Veritas

data/lib/veritas/optimizer/{logic → function}/predicate/exclusion.rb

@@ -2,7 +2,7 @@
 
 module Veritas
   class Optimizer
-    module Logic
+    module Function
       class Predicate
 
         # Abstract base class representing Exclusion optimizations
@@ -11,17 +11,7 @@ module Veritas
 
           # Optimize when the right operand is empty
           class EmptyRightOperand < self
-            include Enumerable::EmptyRightOperand
-
-            # An Exclusion with an empty right operand matches everything
-            #
-            # @return [Tautology]
-            #
-            # @api private
-            def optimize
-              Veritas::Logic::Proposition::Tautology.instance
-            end
-
+            include Enumerable::EmptyRightOperand, Predicate::Tautology
           end # class EmptyRightOperand
 
           # Optimize when the right operand has one entry
@@ -34,20 +24,20 @@ module Veritas
             #
             # @api private
             def optimize
-              Veritas::Logic::Predicate::Inequality.new(left, right.first)
+              Veritas::Function::Predicate::Inequality.new(left, right.first)
             end
 
           end # class OneRightOperand
 
-          Veritas::Logic::Predicate::Exclusion.optimizer = chain(
+          Veritas::Function::Predicate::Exclusion.optimizer = chain(
             ConstantOperands,
             EmptyRightOperand,
             OneRightOperand,
-            UnoptimizedOperand
+            Enumerable::UnoptimizedOperands
           )
 
         end # class Exclusion
       end # class Predicate
-    end # module Logic
+    end # module Function
   end # class Optimizer
 end # module Veritas

data/lib/veritas/optimizer/{logic → function}/predicate/greater_than.rb

@@ -2,7 +2,7 @@
 
 module Veritas
   class Optimizer
-    module Logic
+    module Function
       class Predicate
 
         # Abstract base class representing GreaterThan optimizations
@@ -35,20 +35,21 @@ module Veritas
             #
             # @api private
             def optimizable?
-              operation.class.call(Predicate::Util.min(left), Predicate::Util.max(right))
+              operation.class.call(Util.min(left), Util.max(right))
             end
 
           end # class Tautology
 
-          Veritas::Logic::Predicate::GreaterThan.optimizer = chain(
+          Veritas::Function::Predicate::GreaterThan.optimizer = chain(
             ConstantOperands,
             Contradiction,
             Tautology,
-            NormalizableOperands
+            NormalizableOperands,
+            UnoptimizedOperands
           )
 
         end # class GreaterThan
       end # class Predicate
-    end # module Logic
+    end # module Function
   end # class Optimizer
 end # module Veritas

data/lib/veritas/optimizer/{logic → function}/predicate/greater_than_or_equal_to.rb

@@ -2,7 +2,7 @@
 
 module Veritas
   class Optimizer
-    module Logic
+    module Function
       class Predicate
 
         # Abstract base class representing GreaterThanOrEqualTo optimizations
@@ -11,8 +11,7 @@ module Veritas
 
           # Optimize when the operands are a contradiction
           class Contradiction < self
-            include Comparable::NeverComparable
-            include Predicate::Contradiction
+            include Comparable::NeverComparable, Predicate::Contradiction
 
             # Test if the operands are a contradiction
             #
@@ -42,15 +41,16 @@ module Veritas
 
           end # class Tautology
 
-          Veritas::Logic::Predicate::GreaterThanOrEqualTo.optimizer = chain(
+          Veritas::Function::Predicate::GreaterThanOrEqualTo.optimizer = chain(
             ConstantOperands,
             Contradiction,
             Tautology,
-            NormalizableOperands
+            NormalizableOperands,
+            UnoptimizedOperands
           )
 
         end # class GreaterThanOrEqualTo
       end # class Predicate
-    end # module Logic
+    end # module Function
   end # class Optimizer
 end # module Veritas

data/lib/veritas/optimizer/{logic → function}/predicate/inclusion.rb

@@ -2,7 +2,7 @@
 
 module Veritas
   class Optimizer
-    module Logic
+    module Function
       class Predicate
 
         # Abstract base class representing Inclusion optimizations
@@ -11,17 +11,7 @@ module Veritas
 
           # Optimize when the right operand is empty
           class EmptyRightOperand < self
-            include Enumerable::EmptyRightOperand
-
-            # An Inclusion with an empty right operand matches nothing
-            #
-            # @return [Contradiction]
-            #
-            # @api private
-            def optimize
-              Veritas::Logic::Proposition::Contradiction.instance
-            end
-
+            include Enumerable::EmptyRightOperand, Predicate::Contradiction
           end # class EmptyRightOperand
 
           # Optimize when the right operand has one entry
@@ -34,20 +24,20 @@ module Veritas
             #
             # @api private
             def optimize
-              Veritas::Logic::Predicate::Equality.new(left, right.first)
+              Veritas::Function::Predicate::Equality.new(left, right.first)
             end
 
           end # class OneRightOperand
 
-          Veritas::Logic::Predicate::Inclusion.optimizer = chain(
+          Veritas::Function::Predicate::Inclusion.optimizer = chain(
             ConstantOperands,
             EmptyRightOperand,
             OneRightOperand,
-            UnoptimizedOperand
+            Enumerable::UnoptimizedOperands
           )
 
         end # class Inclusion
       end # class Predicate
-    end # module Logic
+    end # module Function
   end # class Optimizer
 end # module Veritas

data/lib/veritas/optimizer/{logic → function}/predicate/inequality.rb

@@ -2,7 +2,7 @@
 
 module Veritas
   class Optimizer
-    module Logic
+    module Function
       class Predicate
 
         # Abstract base class representing Inequality optimizations
@@ -26,19 +26,19 @@ module Veritas
 
           # Optimize when the operand are a tautology
           class Tautology < self
-            include Comparable::NeverEquivalent
-            include Predicate::Tautology
+            include Comparable::NeverEquivalent, Predicate::Tautology
           end # class Tautology
 
-          Veritas::Logic::Predicate::Inequality.optimizer = chain(
+          Veritas::Function::Predicate::Inequality.optimizer = chain(
             ConstantOperands,
             Contradiction,
             Tautology,
-            NormalizableOperands
+            NormalizableOperands,
+            UnoptimizedOperands
           )
 
         end # class Inequality
       end # class Predicate
-    end # module Logic
+    end # module Function
   end # class Optimizer
 end # module Veritas

data/lib/veritas/optimizer/{logic → function}/predicate/less_than.rb

@@ -2,7 +2,7 @@
 
 module Veritas
   class Optimizer
-    module Logic
+    module Function
       class Predicate
 
         # Abstract base class representing LessThan optimizations
@@ -35,20 +35,21 @@ module Veritas
             #
             # @api private
             def optimizable?
-              operation.class.call(Predicate::Util.max(left), Predicate::Util.min(right))
+              operation.class.call(Util.max(left), Util.min(right))
             end
 
           end # class Tautology
 
-          Veritas::Logic::Predicate::LessThan.optimizer = chain(
+          Veritas::Function::Predicate::LessThan.optimizer = chain(
             ConstantOperands,
             Contradiction,
             Tautology,
-            NormalizableOperands
+            NormalizableOperands,
+            UnoptimizedOperands
           )
 
         end # class LessThan
       end # class Predicate
-    end # module Logic
+    end # module Function
   end # class Optimizer
 end # module Veritas

data/lib/veritas/optimizer/{logic → function}/predicate/less_than_or_equal_to.rb

@@ -2,7 +2,7 @@
 
 module Veritas
   class Optimizer
-    module Logic
+    module Function
       class Predicate
 
         # Abstract base class representing LessThanOrEqualTo optimizations
@@ -11,8 +11,7 @@ module Veritas
 
           # Optimize when the operands are a contradiction
           class Contradiction < self
-            include Comparable::NeverComparable
-            include Predicate::Contradiction
+            include Comparable::NeverComparable, Predicate::Contradiction
 
             # Test if the operands are a contradiction
             #
@@ -42,15 +41,16 @@ module Veritas
 
           end # class Tautology
 
-          Veritas::Logic::Predicate::LessThanOrEqualTo.optimizer = chain(
+          Veritas::Function::Predicate::LessThanOrEqualTo.optimizer = chain(
             ConstantOperands,
             Contradiction,
             Tautology,
-            NormalizableOperands
+            NormalizableOperands,
+            UnoptimizedOperands
           )
 
         end # class LessThanOrEqualTo
       end # class Predicate
-    end # module Logic
+    end # module Function
   end # class Optimizer
 end # module Veritas

data/lib/veritas/optimizer/{logic → function}/predicate/match.rb

@@ -2,18 +2,19 @@
 
 module Veritas
   class Optimizer
-    module Logic
+    module Function
       class Predicate
 
         # Abstract base class representing Match optimizations
         class Match < self
 
-          Veritas::Logic::Predicate::Match.optimizer = chain(
-            ConstantOperands
+          Veritas::Function::Predicate::Match.optimizer = chain(
+            ConstantOperands,
+            UnoptimizedOperands
           )
 
         end # class Match
       end # class Predicate
-    end # module Logic
+    end # module Function
   end # class Optimizer
 end # module Veritas

data/lib/veritas/optimizer/{logic → function}/predicate/no_match.rb

@@ -2,18 +2,19 @@
 
 module Veritas
   class Optimizer
-    module Logic
+    module Function
       class Predicate
 
         # Abstract base class representing NoMatch optimizations
         class NoMatch < self
 
-          Veritas::Logic::Predicate::NoMatch.optimizer = chain(
-            ConstantOperands
+          Veritas::Function::Predicate::NoMatch.optimizer = chain(
+            ConstantOperands,
+            UnoptimizedOperands
           )
 
         end # class NoMatch
       end # class Predicate
-    end # module Logic
+    end # module Function
   end # class Optimizer
 end # module Veritas