axiom 0.1.0

data/lib/axiom/aggregate/mean.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+
+module Axiom
+  class Aggregate
+
+    # The mean of a sequence of numbers
+    class Mean < Aggregate
+
+      DEFAULT = [ 0, nil ].freeze
+
+      # Return the count and mean for a sequence of numbers
+      #
+      # @example
+      #   count, mean = Mean.call([ count, mean ], value)
+      #
+      # @param [Array(Integer, Numeric)] accumulator
+      #
+      # @param [Numeric] value
+      #
+      # @return [Array(Integer, Numeric)]
+      #
+      # @api public
+      def self.call(accumulator, value)
+        return accumulator if value.nil?
+        count, mean = accumulator
+        count       = Count.call(count, value)
+        [ count, mean.nil? ? value.to_f : mean + ((value - mean) / count) ]
+      end
+
+      # Extract the mean from the accumulator
+      #
+      # @example
+      #   mean = Mean.finalize(accumulator)
+      #
+      # @param [Array(Integer, Numeric)] accumulator
+      #
+      # @return [Float]
+      #   returned for a non-empty set
+      # @return [nil]
+      #   returned for an empty set
+      #
+      # @api public
+      def self.finalize(accumulator)
+        accumulator.last
+      end
+
+      # Return the type returned from #call
+      #
+      # @example
+      #   type = Axiom::Aggregate::Mean.type
+      #
+      # @return [Class<Attribute::Float>]
+      #
+      # @api public
+      def type
+        Attribute::Float
+      end
+
+      module Methods
+        extend Aliasable
+
+        inheritable_alias(
+          :average => :mean,
+          :avg     => :mean
+        )
+
+        # Return a mean aggregate function
+        #
+        # @example
+        #   mean = attribute.mean
+        #
+        # @param [Attribute]
+        #
+        # @return [Mean]
+        #
+        # @api public
+        def mean
+          Mean.new(self)
+        end
+
+      end # module Methods
+    end # class Mean
+  end # class Aggregate
+end # module Axiom

data/lib/axiom/aggregate/minimum.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module Axiom
+  class Aggregate
+
+    # The maximum value in a sequence of numbers
+    class Minimum < Aggregate
+
+      DEFAULT = Float::INFINITY
+
+      # Return the minimum value for a sequence of numbers
+      #
+      # @example
+      #   minimum = Minimum.call(minimum, value)
+      #
+      # @param [Numeric] minimum
+      #
+      # @param [Numeric] value
+      #
+      # @return [Numeric]
+      #
+      # @api public
+      def self.call(minimum, value)
+        return minimum if value.nil?
+        value < minimum ? value : minimum
+      end
+
+      # Return the type returned from #call
+      #
+      # @example
+      #   type = Axiom::Aggregate::Minimum.type
+      #
+      # @return [Class<Attribute::Numeric>]
+      #
+      # @api public
+      def type
+        Attribute.infer_type(operand)
+      end
+
+      module Methods
+        extend Aliasable
+
+        inheritable_alias(:min => :minimum)
+
+        # Return a minimum aggregate function
+        #
+        # @example
+        #   minimum = attribute.minimum
+        #
+        # @param [Attribute]
+        #
+        # @return [Minimum]
+        #
+        # @api public
+        def minimum
+          Minimum.new(self)
+        end
+
+      end # module Methods
+    end # class Minimum
+  end # class Aggregate
+end # module Axiom

data/lib/axiom/aggregate/standard_deviation.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+module Axiom
+  class Aggregate
+
+    # The standard deviation of a sequence of numbers
+    class StandardDeviation < Variance
+
+      # Calculate the standard deviation from the accumulator
+      #
+      # @example
+      #   standard_deviation = StandardDeviation.finalize(accumulator)
+      #
+      # @param [Array(Numeric, Integer, Numeric)] _accumulator
+      #
+      # @return [Float]
+      #   returned for a non-empty set
+      # @return [nil]
+      #   returned for an empty set
+      #
+      # @api public
+      def self.finalize(_accumulator)
+        variance = super
+        Math.sqrt(variance) if variance
+      end
+
+      # Return the type returned from #call
+      #
+      # @example
+      #   type = Axiom::Aggregate::StandardDeviation.type
+      #
+      # @return [Class<Attribute::Float>]
+      #
+      # @api public
+      def type
+        Attribute::Float
+      end
+
+      module Methods
+        extend Aliasable
+
+        inheritable_alias(:stddev => :standard_deviation)
+
+        # Return a standard deviation aggregate function
+        #
+        # @example
+        #   standard_deviation = attribute.standard_deviation
+        #
+        # @param [Attribute]
+        #
+        # @return [StandardDeviation]
+        #
+        # @api public
+        def standard_deviation
+          StandardDeviation.new(self)
+        end
+
+      end # module Methods
+    end # class StandardDeviation
+  end # class Aggregate
+end # module Axiom

data/lib/axiom/aggregate/sum.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+module Axiom
+  class Aggregate
+
+    # The sum of a sequence of numbers
+    class Sum < Aggregate
+
+      DEFAULT = 0
+
+      # Return the sum for a sequence of numbers
+      #
+      # @example
+      #   sum = Sum.call(sum, value)
+      #
+      # @param [Numeric] sum
+      #
+      # @param [Object] value
+      #
+      # @return [Numeric]
+      #
+      # @api public
+      def self.call(sum, value)
+        return sum if value.nil?
+        sum + value
+      end
+
+      # Return the default sum
+      #
+      # @example when the operand is a float
+      #   default = sum.default  # => 0.0
+      #
+      # @example when the operand is a decimal
+      #   default = sum.default  # => BigDecimal('0.0')
+      #
+      # @example when the operand is an integer
+      #   default = sum.default  # => 0
+      #
+      # @return [Numeric]
+      #
+      # @todo refactor once functions know their return types
+      #
+      # @api public
+      def default
+        if    type.equal?(Attribute::Float)   then super.to_f
+        elsif type.equal?(Attribute::Decimal) then BigDecimal(super.to_s)
+        else
+          super
+        end
+      end
+
+      # Return the type returned from #call
+      #
+      # @example
+      #   type = Axiom::Aggregate::Sum.type
+      #
+      # @return [Class<Attribute::Numeric>]
+      #
+      # @api public
+      def type
+        Attribute.infer_type(operand)
+      end
+
+      module Methods
+
+        # Return a sum aggregate function
+        #
+        # @example
+        #   sum = attribute.sum
+        #
+        # @param [Attribute]
+        #
+        # @return [Sum]
+        #
+        # @api public
+        def sum
+          Sum.new(self)
+        end
+
+      end # module Methods
+    end # class Sum
+  end # class Aggregate
+end # module Axiom

data/lib/axiom/aggregate/variance.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+
+module Axiom
+  class Aggregate
+
+    # The variance of a sequence of numbers
+    class Variance < Aggregate
+
+      DEFAULT = [ 0, nil, 0.0 ].freeze
+
+      # Return the count, mean, and sum of squares for a sequence of numbers
+      #
+      # @example
+      #   count, mean, sum_of_squares = Variance.call(accumulator, value)
+      #
+      # @param [Array(Integer, Numeric, Float)] accumulator
+      #
+      # @param [Numeric] value
+      #
+      # @return [Array(Integer, Numeric, Numeric)]
+      #
+      # @api public
+      def self.call(accumulator, value)
+        return accumulator if value.nil?
+        mean, sum_of_squares  = accumulator.last(2)
+        delta                 = mean.nil? ? value : value - mean
+        count, new_mean       = Mean.call(accumulator, value)
+        sum_of_squares       += delta * (value - new_mean)
+        [ count, new_mean, sum_of_squares ]
+      end
+
+      # Calculate the variance from the accumulator
+      #
+      # @example
+      #   variance = Variance.finalize(accumulator)
+      #
+      # @param [Array(Numeric, Integer, Float)] accumulator
+      #
+      # @return [Float]
+      #   returned for a non-empty set
+      # @return [nil]
+      #   returned for an empty set
+      #
+      # @api public
+      def self.finalize(accumulator)
+        sum_of_squares, count = accumulator.values_at(2, 0)
+        sum_of_squares / count unless count.zero?
+      end
+
+      # Return the type returned from #call
+      #
+      # @example
+      #   type = Axiom::Aggregate::Variance.type
+      #
+      # @return [Class<Attribute::Float>]
+      #
+      # @api public
+      def type
+        Attribute::Float
+      end
+
+      module Methods
+        extend Aliasable
+
+        inheritable_alias(:var => :variance)
+
+        # Return a variance aggregate function
+        #
+        # @example
+        #   variance = attribute.variance
+        #
+        # @param [Attribute]
+        #
+        # @return [Variance]
+        #
+        # @api public
+        def variance
+          Variance.new(self)
+        end
+
+      end # module Methods
+    end # class Variance
+  end # class Aggregate
+end # module Axiom

data/lib/axiom/algebra/difference.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+module Axiom
+  module Algebra
+
+    # The difference between relations
+    class Difference < Relation
+      include Relation::Operation::Set
+
+      # Iterate over each tuple in the set
+      #
+      # @example
+      #   difference = Difference.new(left, right)
+      #   difference.each { |tuple| ... }
+      #
+      # @yield [tuple]
+      #
+      # @yieldparam [Tuple] tuple
+      #   each tuple in the set
+      #
+      # @return [self]
+      #
+      # @api public
+      def each
+        return to_enum unless block_given?
+        left.each { |tuple| yield tuple unless right.include?(tuple) }
+        self
+      end
+
+      # Insert a relation into the Difference
+      #
+      # Add the relation to the left operand, and remove from the right operand
+      # so that it not removed by the difference operation.
+      #
+      # @example
+      #   new_relation = difference.insert(other)
+      #
+      # @param [Relation] other
+      #
+      # @return [Difference]
+      #
+      # @api public
+      def insert(other)
+        left.insert(coerce(other).difference(right)).difference(right)
+      end
+
+      # Delete a relation from the Difference
+      #
+      # Remove the relation from the left operand, and add it to the right
+      # operand so that it is removed by the difference operation.
+      #
+      # @example
+      #   new_relation = difference.delete(other)
+      #
+      # @param [Relation] other
+      #
+      # @return [Difference]
+      #
+      # @api public
+      def delete(other)
+        left.delete(coerce(other).difference(right)).difference(right)
+      end
+
+      module Methods
+        extend Aliasable
+
+        inheritable_alias(:- => :difference)
+
+        # Return the difference between relations
+        #
+        # @example
+        #   difference = relation.difference(other)
+        #
+        # @param [Relation] other
+        #
+        # @return [Difference]
+        #
+        # @api public
+        def difference(other)
+          Difference.new(self, other)
+        end
+
+      end # module Methods
+
+      Relation.class_eval { include Methods }
+
+    end # class Difference
+  end # module Algebra
+end # module Axiom