veritas 0.0.3 → 0.0.4

data/lib/veritas/core_ext/date.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 # Extend Date with methods to find the previous Date
 class Date
 

data/lib/veritas/core_ext/range.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 # Extend Range with methods to normalize and find overlapping ranges
 class Range
 

data/lib/veritas/core_ext/time.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 # Extend Time with methods to find the previous Time
 class Time
 

data/lib/veritas/function/binary.rb

@@ -0,0 +1,107 @@
+# encoding: utf-8
+
+module Veritas
+  class Function
+
+    # Mixin for binary functions
+    module Binary
+      include Operation::Binary
+
+      # Evaluate the binary connective using the tuple
+      #
+      # @example
+      #   binary.call(tuple)  # => true or false
+      #
+      # @param [Tuple] tuple
+      #   the tuple to pass to #call in the left and right operands
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def call(tuple)
+        util = self.class
+        util.call(
+          util.extract_value(left,  tuple),
+          util.extract_value(right, tuple)
+        )
+      end
+
+      # Rename the contained attributes with the provided aliases
+      #
+      # @example
+      #   renamed = binary.rename(aliases)
+      #
+      # @param [Algebra::Rename::Aliases] aliases
+      #   the old and new attributes
+      #
+      # @return [self]
+      #   if the left and right operands are not renamed
+      # @return [Binary]
+      #   if the left or right operand is renamed
+      #
+      # @todo handle case where left/right are literals
+      #
+      # @api public
+      def rename(aliases)
+        left  = self.left
+        right = self.right
+        util  = self.class
+
+        renamed_left  = util.rename_attributes(left,  aliases)
+        renamed_right = util.rename_attributes(right, aliases)
+
+        if left.equal?(renamed_left) && right.equal?(renamed_right)
+          self
+        else
+          util.new(renamed_left, renamed_right)
+        end
+      end
+
+      # Compare the operation with the other operation for equivalency
+      #
+      # @example
+      #   binary == other  # => true or false
+      #
+      # @param [Object] other
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def ==(other)
+        (kind_of?(other.class) || other.kind_of?(self.class)) &&
+        left  == other.left                                   &&
+        right == other.right
+      end
+
+      # Mixin for invertable binary functions
+      module Invertible
+
+        # Hook called when module is included
+        #
+        # @param [Module] descendant
+        #   the module or class including Invertible
+        #
+        # @return [self]
+        #
+        # @api private
+        def self.included(descendant)
+          descendant.memoize :inverse
+        end
+
+        # Return the inverse function
+        #
+        # @example
+        #   inverse = function.inverse
+        #
+        # @return [Function]
+        #
+        # @api public
+        def inverse
+          self.class.inverse.new(left, right).
+            memoize(:inverse, self)
+        end
+
+      end # module Invertible
+    end # module Binary
+  end # class Function
+end # module Veritas

data/lib/veritas/function/comparable.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+module Veritas
+  class Function
+
+    # A mixin for functions with directly compared operands
+    module Comparable
+      include Immutable
+
+      # Hook called when module is included
+      #
+      # @param [Module] descendant
+      #   the module or class including Comparable
+      #
+      # @return [self]
+      #
+      # @api private
+      def self.included(descendant)
+        descendant.extend ClassMethods
+        self
+      end
+
+      # Return a string representing the function
+      #
+      # @example
+      #   function.inspect  # (String representation of a Function)
+      #
+      # @return [String]
+      #
+      # @api public
+      def inspect
+        "(#{left.inspect} #{self.class.operation} #{right.inspect})"
+      end
+
+      module ClassMethods
+
+        # Evaluate the values using the ruby operation
+        #
+        # @example
+        #   function.call(left, right)  # => true or false
+        #
+        # @param [Object] left
+        # @param [Object] right
+        #
+        # @return [Object]
+        #
+        # @api public
+        def call(left, right)
+          left.send(operation, right)
+        end
+
+      end # module Classmethods
+    end # class Predicate
+  end # class Function
+end # module Veritas

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

@@ -1,9 +1,12 @@
+# encoding: utf-8
+
 module Veritas
-  module Logic
+  class Function
     class Connective
 
       # A logical AND between expressions
-      class Conjunction < Binary
+      class Conjunction < Connective
+        include Binary, Binary::Invertible
 
         # Evaluate the operands using a logical AND
         #
@@ -29,10 +32,23 @@ module Veritas
           left && right
         end
 
+        # Return the inverse connective
+        #
+        # @example
+        #   disjunction = conjunction.inverse
+        #
+        # @return [Disjunction]
+        #
+        # @api public
+        def inverse
+          Disjunction.new(Negation.new(left), Negation.new(right)).
+            memoize(:inverse, self)
+        end
+
         # Return a string representing the conjunction
         #
         # @example
-        #   conjunction.inspect  # "<Expression1> AND <Expression2>"
+        #   conjunction.inspect  # => "<Function1> AND <Function2>"
         #
         # @return [String]
         #
@@ -51,7 +67,7 @@ module Veritas
           # @example
           #   conjunction = expression.and(other)
           #
-          # @param [Expression] other
+          # @param [Function] other
           #
           # @return [Conjunction]
           #
@@ -62,9 +78,11 @@ module Veritas
 
         end # module Methods
 
-        Expression.class_eval { include Methods }
+        Connective.class_eval { include Methods }
+
+        memoize :inverse
 
       end # class Conjunction
     end # class Connective
-  end # module Logic
+  end # class Function
 end # module Veritas

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

@@ -1,9 +1,12 @@
+# encoding: utf-8
+
 module Veritas
-  module Logic
+  class Function
     class Connective
 
       # A logical OR between expressions
-      class Disjunction < Binary
+      class Disjunction < Connective
+        include Binary, Binary::Invertible
 
         # Evaluate the operands using a logical OR
         #
@@ -29,10 +32,23 @@ module Veritas
           left || right
         end
 
+        # Return the inverse connective
+        #
+        # @example
+        #   conjunction = disjunction.inverse
+        #
+        # @return [Conjunction]
+        #
+        # @api public
+        def inverse
+          Conjunction.new(Negation.new(left), Negation.new(right)).
+            memoize(:inverse, self)
+        end
+
         # Return a string representing the disjunction
         #
         # @example
-        #   disjunction.inspect  # "<Expression1> OR <Expression2>"
+        #   disjunction.inspect  # => "<Function1> OR <Function2>"
         #
         # @return [String]
         #
@@ -51,7 +67,7 @@ module Veritas
           # @example
           #   disjunction = expression.or(other)
           #
-          # @param [Expression] other
+          # @param [Function] other
           #
           # @return [Disjunction]
           #
@@ -62,9 +78,11 @@ module Veritas
 
         end # module Methods
 
-        Expression.class_eval { include Methods }
+        Connective.class_eval { include Methods }
+
+        memoize :inverse
 
       end # class Disjunction
     end # class Connective
-  end # module Logic
+  end # class Function
 end # module Veritas

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

@@ -1,9 +1,12 @@
+# encoding: utf-8
+
 module Veritas
-  module Logic
+  class Function
     class Connective
 
       # A logical negation of an expression
-      class Negation < Unary
+      class Negation < Connective
+        include Unary, Unary::Invertible
 
         # Evaluate the operands using a logical NOT
         #
@@ -27,7 +30,7 @@ module Veritas
         # @example
         #   operand = negation.inverse
         #
-        # @return [Expression]
+        # @return [Function]
         #
         # @api public
         def inverse
@@ -37,13 +40,13 @@ module Veritas
         # Return a string representing the negation
         #
         # @example
-        #   negation.inspect  # not(<Expression>)
+        #   negation.inspect  # not(<Function>)
         #
         # @return [String]
         #
         # @api public
         def inspect
-          "not(#{operand.inspect})"
+          "NOT(#{operand.inspect})"
         end
 
         module Methods
@@ -54,25 +57,43 @@ module Veritas
 
           inheritable_alias(:- => :not)
 
-          # Logically negate then AND the expression
+          # Negate the expression or logically AND and negate another expression
+          #
+          # @example with no argument
+          #   negation = expression.not
           #
-          # @example
+          # @example with other argument
           #   conjunction = expression.not(other)
           #
-          # @param [Expression] other
+          # @overload not
+          #   Negates the expression
+          #
+          #   @return [Negation]
           #
-          # @return [Conjunction]
+          # @overload not(other)
+          #   Logically AND the other negated expression
+          #
+          #   @param [Function] other
+          #     optional other function to and
+          #
+          #   @return [Conjunction]
           #
           # @api public
-          def not(other)
-            self.and(Negation.new(other))
+          def not(other = Undefined)
+            if other.equal?(Undefined)
+              Negation.new(self)
+            else
+              self.and(Negation.new(other))
+            end
           end
 
         end # module Methods
 
-        Expression.class_eval { include Methods }
+        Connective.class_eval { include Methods }
+
+        memoize :inverse
 
       end # class Negation
     end # class Connective
-  end # module Logic
+  end # class Function
 end # module Veritas

data/lib/veritas/function/connective.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Veritas
+  class Function
+
+    # Abstract base class for logical connectives
+    class Connective < Function
+      include AbstractClass
+
+      # Return the type returned from #call
+      #
+      # @return [Class<Attribute::Boolean>]
+      #
+      # @api public
+      def type
+        Attribute::Boolean
+      end
+
+    end # class Connective
+  end # class Function
+end # module Veritas

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

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module Veritas
+  class Function
+    class Numeric
+
+      # A class representing an absolute function
+      class Absolute < Numeric
+        include Unary
+
+        # Return the absolute value
+        #
+        # @example
+        #   absolute_value = Absolute.call(value)
+        #
+        # @param [Numeric] value
+        #
+        # @return [Numeric]
+        #
+        # @api public
+        def self.call(value)
+          value.abs
+        end
+
+        # Return a string representing the absolute function
+        #
+        # @example
+        #   absolute.inspect  # => "ABS(-1)"
+        #
+        # @return [String]
+        #
+        # @api public
+        def inspect
+          "ABS(#{operand.inspect})"
+        end
+
+        module Methods
+          extend Aliasable
+
+          inheritable_alias(:abs => :absolute)
+
+          # Return an absolute function
+          #
+          # @example
+          #   absolute = attribute.absolute
+          #
+          # @return [Absolute]
+          #
+          # @api public
+          def absolute
+            Absolute.new(self)
+          end
+
+        end # module Methods
+
+        Attribute::Numeric.class_eval { include Methods }
+        Numeric.class_eval            { include Methods }
+
+      end # class Absolute
+    end # class Numeric
+  end # class Function
+end # module Veritas

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

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module Veritas
+  class Function
+    class Numeric
+
+      # A class representing an addition function
+      class Addition < Numeric
+        include Binary, Comparable
+
+        # Return the Addition operation
+        #
+        # @example
+        #   Addition.operation  # => :+
+        #
+        # @return [Symbol]
+        #
+        # @api public
+        def self.operation
+          :+
+        end
+
+        # Return the inverse function class
+        #
+        # @example
+        #   Addition.inverse  # => Subtraction
+        #
+        # @return [Class<Subtraction>]
+        #
+        # @api public
+        def self.inverse
+          Subtraction
+        end
+
+        module Methods
+          extend Aliasable
+
+          inheritable_alias(:+ => :add)
+
+          # Return an addition function
+          #
+          # @example
+          #   addition = attribute.add(other)
+          #
+          # @param [Object] other
+          #
+          # @return [Addition]
+          #
+          # @api public
+          def add(other)
+            Addition.new(self, other)
+          end
+
+        end # module Methods
+
+        Attribute::Numeric.class_eval { include Methods }
+        Numeric.class_eval            { include Methods }
+
+      end # class Addition
+    end # class Numeric
+  end # class Function
+end # module Veritas

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

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Veritas
+  class Function
+    class Numeric
+
+      # A mixin for numeric Binary functions
+      module Binary
+        include Function::Binary
+
+        # Return the type returned from #call
+        #
+        # @return [Class<Attribute::Numeric>]
+        #
+        # @api public
+        def type
+          util       = Attribute
+          left_type  = util.infer_type(left)
+          right_type = util.infer_type(right)
+          left_type.equal?(right_type) ? left_type : Attribute::Numeric
+        end
+
+      end # module Binary
+    end # class Numeric
+  end # class Function
+end # module Veritas

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

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+module Veritas
+  class Function
+    class Numeric
+
+      # A class representing a division function
+      class Division < Numeric
+        include Binary, Comparable
+
+        # Return the Division operation
+        #
+        # @example
+        #   Division.operation  # => :/
+        #
+        # @return [Symbol]
+        #
+        # @api public
+        def self.operation
+          :/
+        end
+
+        # Return the inverse function class
+        #
+        # @example
+        #   Division.inverse  # => Multiplication
+        #
+        # @return [Class<Multiplication>]
+        #
+        # @api public
+        def self.inverse
+          Multiplication
+        end
+
+        # Return the type returned from #call
+        #
+        # @return [Class<Attribute::Float>]
+        #
+        # @api public
+        def type
+          Attribute::Float
+        end
+
+        module Methods
+          extend Aliasable
+
+          inheritable_alias(:/ => :divide)
+
+          # Return a division function
+          #
+          # @example
+          #   division = attribute.divide(other)
+          #
+          # @param [Object] other
+          #
+          # @return [Division]
+          #
+          # @api public
+          def divide(other)
+            Division.new(self, other)
+          end
+
+        end # module Methods
+
+        Attribute::Numeric.class_eval { include Methods }
+        Numeric.class_eval            { include Methods }
+
+      end # class Division
+    end # class Numeric
+  end # class Function
+end # module Veritas