axiom 0.1.0

data/lib/axiom/function/numeric.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+module Axiom
+  class Function
+
+    # Abstract class for Numeric functions
+    class Numeric < Function
+      include AbstractType
+    end # class Numeric
+  end # class Function
+end # module Axiom

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

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+module Axiom
+  class Function
+    class Numeric
+
+      # A class representing an absolute function
+      class Absolute < Numeric
+        include Unary
+
+        # Return the absolute operation
+        #
+        # @example
+        #   Absolute.operation  # => :abs
+        #
+        # @return [Symbol]
+        #
+        # @api public
+        def self.operation
+          :abs
+        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 Axiom

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

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module Axiom
+  class Function
+    class Numeric
+
+      # A class representing an addition function
+      class Addition < Numeric
+        include Comparable, Binary
+
+        # 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 Axiom

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

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

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

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+module Axiom
+  class Function
+    class Numeric
+
+      # A class representing a division function
+      class Division < Numeric
+        include Comparable, Binary
+
+        # 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 Axiom

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

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+module Axiom
+  class Function
+    class Numeric
+
+      # A class representing a exponentiation function
+      class Exponentiation < Numeric
+        include Comparable, Binary::Invertible, Binary
+
+        undef_method :inverse
+
+        # Return the Exponentiation operation
+        #
+        # @example
+        #   Exponentiation.operation  # => :**
+        #
+        # @return [Symbol]
+        #
+        # @api public
+        def self.operation
+          :**
+        end
+
+        # Return the inverse function
+        #
+        # @example
+        #   inverse = exponentiation.inverse
+        #
+        # @return [Exponentiation]
+        #
+        # @api public
+        def inverse
+          self.class.new(left, Division.new(1, right)).memoize(:inverse, self)
+        end
+
+        module Methods
+          extend Aliasable
+
+          inheritable_alias(
+            :**  => :exponent,
+            :pow => :exponent
+          )
+
+          # Return an exponential function
+          #
+          # @example
+          #   exponentiation = attribute.exponent(other)
+          #
+          # @param [Object] other
+          #
+          # @return [Exponentiation]
+          #
+          # @api public
+          def exponent(other)
+            Exponentiation.new(self, other)
+          end
+
+        end # module Methods
+
+        Attribute::Numeric.class_eval { include Methods }
+        Numeric.class_eval            { include Methods }
+
+        memoize :inverse
+
+      end # class Exponentiation
+    end # class Numeric
+  end # class Function
+end # module Axiom

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

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module Axiom
+  class Function
+    class Numeric
+
+      # A class representing a modulo function
+      class Modulo < Numeric
+        include Comparable, Binary
+
+        # Return the Modulo operation
+        #
+        # @example
+        #   Modulo.operation  # => :%
+        #
+        # @return [Symbol]
+        #
+        # @api public
+        def self.operation
+          :%
+        end
+
+        module Methods
+          extend Aliasable
+
+          inheritable_alias(
+            :%   => :modulo,
+            :mod => :modulo
+          )
+
+          # Return a modulo function
+          #
+          # @example
+          #   modulo = attribute.modulo(other)
+          #
+          # @param [Object] other
+          #
+          # @return [Modulo]
+          #
+          # @api public
+          def modulo(other)
+            Modulo.new(self, other)
+          end
+
+        end # module Methods
+
+        Attribute::Numeric.class_eval { include Methods }
+        Numeric.class_eval            { include Methods }
+
+      end # class Modulo
+    end # class Numeric
+  end # class Function
+end # module Axiom

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

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

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

@@ -0,0 +1,75 @@
+# encoding: utf-8
+
+module Axiom
+  class Function
+    class Numeric
+
+      # A class representing a square root function
+      class SquareRoot < Numeric
+        include Unary::Invertible, Unary
+
+        undef_method :inverse
+
+        # Return the square root of the value
+        #
+        # @example
+        #   square_root = SquareRoot.call(value)
+        #
+        # @param [Numeric] value
+        #
+        # @return [Numeric]
+        #
+        # @api public
+        def self.call(value)
+          Math.sqrt(value)
+        end
+
+        # Return the inverse function
+        #
+        # @example
+        #   inverse = square_root.inverse
+        #
+        # @return [Exponentiation]
+        #
+        # @api public
+        def inverse
+          Exponentiation.new(operand, 2).memoize(:inverse, self)
+        end
+
+        # Return the type returned from #call
+        #
+        # @return [Class<Attribute::Float>]
+        #
+        # @api public
+        def type
+          Attribute::Float
+        end
+
+        module Methods
+          extend Aliasable
+
+          inheritable_alias(:sqrt => :square_root)
+
+          # Return a square root function
+          #
+          # @example
+          #   square_root = attribute.square_root
+          #
+          # @return [SquareRoot]
+          #
+          # @api public
+          def square_root
+            SquareRoot.new(self)
+          end
+
+        end # module Methods
+
+        Attribute::Numeric.class_eval { include Methods }
+        Numeric.class_eval            { include Methods }
+
+        memoize :inverse
+
+      end # class SquareRoot
+    end # class Numeric
+  end # class Function
+end # module Axiom