dydx 0.1.3 → 0.1.4

data/lib/dydx/algebra/inverse.rb

@@ -15,12 +15,26 @@ module Dydx
         end
       end
 
-      def differentiate(sym=:x)
+      def subst(hash = {})
+        case operator
+        when :+ then x.subst(hash) * -1
+        when :* then x.subst(hash) ** -1
+        end
+      end
+
+      def to_f
+        case operator
+        when :+ then x.to_f * -1
+        when :* then x.to_f ** -1
+        end
+      end
+
+      def differentiate(sym = :x)
         case operator
         when :+
           inverse(x.differentiate(sym), :+)
         when :*
-          inverse(x.differentiate(sym) * inverse(x ^ 2, :*), :+)
+          inverse(x.differentiate(sym) * inverse(x ** 2, :*), :+)
         end
       end
       alias_method :d, :differentiate

data/lib/dydx/algebra/operator/formula.rb

@@ -1,6 +1,3 @@
-require 'dydx/algebra/operator/common_parts'
-require 'dydx/algebra/operator/parts/formula'
-
 module Dydx
   module Algebra
     module Operator
@@ -8,7 +5,6 @@ module Dydx
         include Parts::Base
         include Parts::Formula
         include Parts::General
-        include Parts::Interface
       end
     end
   end

data/lib/dydx/algebra/operator/general.rb

@@ -1,13 +1,9 @@
-require 'dydx/algebra/operator/common_parts'
-require 'dydx/algebra/operator/parts/general'
-
 module Dydx
   module Algebra
     module Operator
       module General
         include Parts::Base
         include Parts::General
-        include Parts::Interface
       end
     end
   end

data/lib/dydx/algebra/operator/inverse.rb

@@ -1,6 +1,3 @@
-require 'dydx/algebra/operator/common_parts'
-require 'dydx/algebra/operator/parts/inverse'
-
 module Dydx
   module Algebra
     module Operator
@@ -8,7 +5,6 @@ module Dydx
         include Parts::Base
         include Parts::Inverse
         include Parts::General
-        include Parts::Interface
       end
     end
   end

data/lib/dydx/algebra/operator/num.rb

@@ -1,6 +1,3 @@
-require 'dydx/algebra/operator/common_parts'
-require 'dydx/algebra/operator/parts/num'
-
 module Dydx
   module Algebra
     module Operator
@@ -8,7 +5,6 @@ module Dydx
         include Parts::Base
         include Parts::Num
         include Parts::General
-        include Parts::Interface
       end
     end
   end

data/lib/dydx/algebra/operator/parts/base.rb

@@ -3,9 +3,9 @@ module Dydx
     module Operator
       module Parts
         module Base
-          %w(+ * ^).map(&:to_sym).each do |operator|
+          %w(+ * **).map(&:to_sym).each do |operator|
             define_method(operator) do |x|
-              ::Algebra::Formula.new(self, x, operator.to_sym)
+              ::Algebra::Formula.new(operator.to_sym, self, x)
             end
           end
         end

data/lib/dydx/algebra/operator/parts/formula.rb

@@ -3,60 +3,81 @@ module Dydx
     module Operator
       module Parts
         module Formula
-          %w(+ *).map(&:to_sym).each do |operator|
-            define_method(operator) do |x|
-              if self.operator == operator
-                if f.combinable?(x, operator)
-                  f.send(operator, x).send(operator, g)
-                elsif g.combinable?(x, operator)
-                  g.send(operator, x).send(operator, f)
+          %w(+ *).map(&:to_sym).each do |op|
+            define_method(op) do |rtr|
+              if self.operator == op
+                if f.combinable?(rtr, op)
+                  _(
+                    _(trs[0], op, rtr), op, trs[1]
+                  )
+                elsif g.combinable?(rtr, op)
+                  _(
+                    _(trs[1], op, rtr), op, trs[0]
+                  )
                 else
-                  super(x)
+                  super(rtr)
                 end
-              elsif formula?(sub_ope(operator)) && openable?(operator, x)
-                f.send(operator, x).send(sub_ope(operator), g.send(operator, x))
-              elsif formula?(super_ope(operator)) && x.formula?(super_ope(operator))
-                w1, w2 = common_factors(x)
-                return super(x) unless (w1 && w2) && (super_ope(operator).commutative? || w1 == w2)
+              elsif formula?(op.sub) && openable?(op, rtr)
+                _(
+                  _(trs[0], op, rtr), op.sub, _(trs[1], op, rtr)
+                )
+              elsif formula?(op.super) && rtr.formula?(op.super)
+                cmn_fct = (trs & rtr.trs).first
+                return super(rtr) unless cmn_fct
 
-                case operator
-                when :+
-                  send(w1).send(super_ope(operator), send(rest(w1)).send(operator, x.send(rest(w2))))
-                when :*
-                  case w1
-                  when :f
-                    send(w1).send(super_ope(operator), send(rest(w1)).send(sub_ope(operator), x.send(rest(w2))))
-                  when :g
-                    send(w1).send(super_ope(operator), send(rest(w1)).send(operator, x.send(rest(w2)))).commutate!
+                if op.super.commutative?
+                  _(
+                    cmn_fct, op.super, _(delete(cmn_fct), op, rtr.delete(cmn_fct))
+                  )
+                else
+                  return super(rtr) if index(cmn_fct) != rtr.index(cmn_fct)
+
+                  case index(cmn_fct)
+                  when 0
+                    _(
+                      cmn_fct, op.super, _(delete(cmn_fct), op.sub, rtr.delete(cmn_fct))
+                    )
+                  when 1
+                    _(
+                      _(delete(cmn_fct), op, rtr.delete(cmn_fct)), op.super, cmn_fct
+                    )
                   end
                 end
-              elsif formula?(super_ope(operator)) && x.inverse?(operator) && x.x.formula?(super_ope(operator))
-                w1, w2 = common_factors(x.x)
-                return super(x) unless (w1 && w2) && (super_ope(operator).commutative? || w1 == w2)
+              elsif formula?(op.super) && rtr.inverse?(op) && rtr.x.formula?(op.super)
+                cmn_fct = (trs & rtr.x.trs).first
+                return super(rtr) unless cmn_fct
 
-                case operator
-                when :+
-                  send(w1).send(super_ope(operator), send(rest(w1)).send(inverse_ope(operator), x.x.send(rest(w2))))
-                when :*
-                  case w1
-                  when :f
-                    send(w1).send(super_ope(operator), send(rest(w1)).send(inverse_ope(sub_ope(operator)), x.x.send(rest(w2))))
-                  when :g
-                    send(w1).send(super_ope(operator), send(rest(w1)).send(inverse_ope(operator), x.x.send(rest(w2)))).commutate!
+                if op.super.commutative?
+                  _(
+                    cmn_fct, op.super, _(delete(cmn_fct), op.inv, rtr.x.delete(cmn_fct))
+                  )
+                else
+                  return super(rtr) if index(cmn_fct) != rtr.x.index(cmn_fct)
+                  case index(cmn_fct)
+                  when 0
+                    _(
+                      cmn_fct, op.super, _(delete(cmn_fct), op.sub.inv, rtr.x.delete(cmn_fct))
+                    )
+                  when 1
+                    _(
+                      _(delete(cmn_fct), op.inv, rtr.x.delete(cmn_fct)), op.super, cmn_fct
+                    )
                   end
                 end
               else
-                super(x)
+                super(rtr)
               end
             end
           end
 
-          %w(^).map(&:to_sym).each do |operator|
-            define_method(operator) do |x|
-              if formula?(sub_ope(operator)) && openable?(operator, x)
-                f.send(operator, x).send(sub_ope(operator), g.send(operator, x))
+          %w(**).map(&:to_sym).each do |op|
+            define_method(op) do |rtr|
+              if formula?(op.sub) && openable?(op, rtr)
+                _(
+                  _(trs[0], op, rtr), op.sub, _(trs[1], op, rtr)
+                )
               else
-                super(x)
+                super(rtr)
               end
             end
           end

data/lib/dydx/algebra/operator/parts/general.rb

@@ -2,48 +2,94 @@ module Dydx
   module Algebra
     module Operator
       module Parts
-        module General
-          %w(+ * ^).map(&:to_sym).each do |operator|
+        module Interface
+          %w(+ - * / ** %).map(&:to_sym).each do |operator|
+            define_method(operator) do |x|
+              x = _(x) if x.is_a?(Numeric)
+              if operator == :/ && x.zero?
+                fail ZeroDivisionError
+              elsif [:-, :/].include?(operator)
+                send(operator.inv, inverse(x, operator.inv))
+              else
+                super(x)
+              end
+            end
+          end
+        end
+
+        module Associative
+          %w(+ * **).map(&:to_sym).each do |operator|
+            define_method(operator) do |x|
+              if operator.associative?
+                if x.formula?(operator)
+                  if combinable?(x.f, operator)
+                    send(operator, x.f).send(operator, x.g)
+                  elsif combinable?(x.g, operator)
+                    send(operator, x.g).send(operator, x.f)
+                  else
+                    super(x)
+                  end
+                elsif x.is_a?(Inverse) && x.operator == operator && x.x.formula?(operator)
+                  if combinable?(x.x.f, operator)
+                    send(operator, inverse(x.x.f, operator)).send(operator, inverse(x.x.g, operator))
+                  elsif combinable?(x.x.g, operator)
+                    send(operator, inverse(x.x.g, operator)).send(operator, inverse(x.x.f, operator))
+                  else
+                    super(x)
+                  end
+                else
+                  super(x)
+                end
+              else
+                super(x)
+              end
+            end
+          end
+        end
+
+        module General1
+          %w(+ * **).map(&:to_sym).each do |operator|
             define_method(operator) do |x|
-              if x.is_0?
+              if x.zero?
                 case operator
-                when :+ then self
-                when :* then x
-                when :^ then e1
+                when :+  then self
+                when :*  then x
+                when :** then e1
                 end
-              elsif x.is_1?
+              elsif x.one?
                 case operator
-                when :+ then super(x)
-                when :* then self
-                when :^ then self
+                when :+  then super(x)
+                when :*  then self
+                when :** then self
                 end
               elsif self == x
                 case operator
-                when :+ then _(2) * self
-                when :* then self ^ _(2)
-                when :^ then super(x)
+                when :+  then _(2) * self
+                when :*  then self ** _(2)
+                when :** then super(x)
                 end
-              elsif operator == :+ && inverse?(:+, x)
-                e0
-              elsif operator == :* && inverse?(:*, x)
-                e1
-              elsif [:+, :*].include?(operator) && x.formula?(operator)
-                if combinable?(x.f, operator)
-                  send(operator, x.f).send(operator, x.g)
-                elsif combinable?(x.g, operator)
-                  send(operator, x.g).send(operator, x.f)
-                else
-                  super(x)
+              elsif inverse?(operator, x)
+                case operator
+                when :+ then e0
+                when :* then e1
                 end
-              elsif x.is_a?(Inverse) && x.operator == operator && x.x.formula?(operator)
-                if combinable?(x.x.f, operator)
-                  send(operator, inverse(x.x.f, operator)).send(operator, inverse(x.x.g, operator))
-                elsif combinable?(x.x.g, operator)
-                  send(operator, inverse(x.x.g, operator)).send(operator, inverse(x.x.f, operator))
+              elsif [:+, :*].include?(operator)
+                if x.formula?(operator.super) && self == x.f
+                  send(operator.super, (1 + x.g))
                 else
                   super(x)
                 end
-              elsif operator == :* && x.inverse?(:+)
+              else
+                super(x)
+              end
+            end
+          end
+        end
+
+        module General2
+          %w(+ * **).map(&:to_sym).each do |operator|
+            define_method(operator) do |x|
+              if operator == :* && x.inverse?(:+)
                 -(self * x.x)
               else
                 super(x)
@@ -51,6 +97,13 @@ module Dydx
             end
           end
         end
+
+        module General
+          include General2
+          include General1
+          include Associative
+          include Interface
+        end
       end
     end
   end

data/lib/dydx/algebra/operator/parts/inverse.rb

@@ -3,17 +3,17 @@ module Dydx
     module Operator
       module Parts
         module Inverse
-          %w(+ * ^).map(&:to_sym).each do |operator|
+          %w(+ * **).map(&:to_sym).each do |operator|
             define_method(operator) do |x|
               if inverse?(operator, x)
                 case operator
                 when :+ then e0
                 when :* then e1
                 end
-              elsif !x.is_a?(Inverse) && operator == :+
+              elsif operator.eql?(:+) && !x.is_a?(Inverse)
                 x + self
-              elsif self.operator == :* && operator == :^
-                inverse(self.x ^ x, :*)
+              elsif operator.eql?(:**) && self.operator.eql?(:*)
+                inverse(self.x ** x, :*)
               else
                 super(x)
               end

data/lib/dydx/algebra/operator/parts/num.rb

@@ -3,31 +3,36 @@ module Dydx
     module Operator
       module Parts
         module Num
-          %w(+ * ^).map(&:to_sym).each do |operator|
+          %w(+ * **).map(&:to_sym).each do |operator|
             define_method(operator) do |x|
-              if is_0?
+              if x.is_a?(Num)
+                _(n.send(operator, x.n))
+              elsif operator == :+ && x.inverse?(:+) && x.x.is_a?(Num)
+                _(n - x.x.n)
+              elsif operator == :* && x.inverse?(:*) && x.x.is_a?(Num) && n % x.x.n == 0
+                _(n / x.x.n)
+              elsif zero?
                 case operator
                 when :+ then x
                 when :* then e0
-                when :^ then e0
+                when :** then e0
                 end
-              elsif is_1?
+              elsif one?
                 case operator
                 when :+ then super(x)
                 when :* then x
-                when :^ then e1
+                when :** then e1
                 end
-              elsif x.is_a?(Num)
-                _(n.send(operator, x.n))
-              elsif operator == :+ && x.inverse?(:+) && x.x.is_a?(Num)
-                _(n - x.x.n)
-              elsif operator == :* && x.inverse?(:*) && x.x.is_a?(Num)
-                _(n / x.x.n)
               else
                 super(x)
               end
             end
           end
+
+          def %(num)
+            fail ArgumentError, "#{num} should be Num class object" unless num.is_a?(Num)
+            _(n % num.n)
+          end
         end
       end
     end

data/lib/dydx/algebra/operator/parts/symbol.rb

@@ -4,10 +4,10 @@ module Dydx
       module Parts
         module Symbol
           def *(x)
-            if x.formula?(:^) &&
+            if x.formula?(:**) &&
               self == x.f
 
-              self ^ (1 + x.g)
+              self ** (1 + x.g)
             else
               super(x)
             end

data/lib/dydx/algebra/set.rb

@@ -1,33 +1,210 @@
-require 'dydx/algebra/set/base'
-require 'dydx/algebra/set/num'
-require 'dydx/algebra/set/fixnum'
-require 'dydx/algebra/set/float'
-require 'dydx/algebra/set/symbol'
-require 'dydx/algebra/set/e'
-require 'dydx/algebra/set/pi'
-require 'dydx/algebra/set/log'
-require 'dydx/algebra/set/sin'
-require 'dydx/algebra/set/cos'
-require 'dydx/algebra/set/tan'
+require 'dydx/algebra/operator/parts/base'
+require 'dydx/algebra/operator/parts/general'
+require 'dydx/algebra/operator/parts/formula'
+require 'dydx/algebra/operator/parts/inverse'
+require 'dydx/algebra/operator/parts/num'
+
+require 'dydx/algebra/operator/inverse'
+require 'dydx/algebra/operator/formula'
+require 'dydx/algebra/operator/num'
+require 'dydx/algebra/operator/general'
+
+require 'dydx/algebra/formula'
+require 'dydx/algebra/inverse'
 
 module Dydx
   module Algebra
     module Set
-      def e0
-        eval("$e0 ||= Num.new(0)")
+      module Base
+        include Helper
+
+        # TODO: Pi should not have attr_accessor
+        def self.included(_klass)
+          attr_accessor :n, :x
+          alias_method :d, :differentiate
+        end
+
+        def initialize(x = nil)
+          case self
+          when Num
+            @n = x
+          when Sin, Cos, Tan, Log, Log10, Log2
+            @x = x
+          end
+        end
+
+        def to_s
+          case self
+          when Num   then n.to_s
+          when Pi    then 'pi'
+          when E     then 'e'
+          when Sin   then "sin( #{x} )"
+          when Cos   then "cos( #{x} )"
+          when Tan   then "tan( #{x} )"
+          when Log   then "log( #{x} )"
+          when Log10 then "log10( #{x} )"
+          when Log2  then "log2( #{x} )"
+          end
+        end
+
+        def to_f
+          case self
+          when Num    then n.to_f
+          when Pi     then Math::PI
+          when E      then Math::E
+          when Symbol then fail ArgumentError
+          when Sin    then Math.sin(x.to_f)
+          when Cos    then Math.cos(x.to_f)
+          when Tan    then Math.tan(x.to_f)
+          when Log    then Math.log(x.to_f)
+          when Log10  then Math.log(x.to_f, 10)
+          when Log2   then Math.log(x.to_f, 2)
+          end
+        end
+
+        def subst(hash = {})
+          case self
+          when Num, Pi, E
+            self
+          when Symbol
+            hash[self] || self
+          when Sin    then sin(x.subst(hash))
+          when Cos    then cos(x.subst(hash))
+          when Tan    then tan(x.subst(hash))
+          when Log    then log(x.subst(hash))
+          when Log10  then log10(x.subst(hash))
+          when Log2   then log2(x.subst(hash))
+          end
+        end
+
+        def differentiate(sym = :x)
+          case self
+          when Num, Pi, E then e0
+          when Symbol     then self == sym ? e1 : e0
+          when Sin        then cos(x) * x.d(sym)
+          when Cos        then -1 * sin(x) * x.d(sym)
+          when Tan        then 1 / (cos(x) ** 2)
+          when Log        then x.d(sym) / (x)
+          when Log10      then x.d(sym) / (x * log(10))
+          when Log2       then x.d(sym) / (x * log(2))
+          end
+        end
       end
 
-      def e1
-        eval("$e1 ||= Num.new(1)")
+      class Num
+        include Base
+        include Operator::Num
+        %w(> >= < <=).each do |operator|
+          define_method(operator) do |x|
+            x = x.n if x.is_a?(Num)
+            n.send(operator, x)
+          end
+        end
       end
-      def _(num)
-        if num >= 0
-          eval("$p#{num} ||= Num.new(num)")
-        else
-          eval("$n#{-1 * num} ||= Num.new(num)")
+
+      class Pi
+        include Base
+        include Operator::General
+      end
+
+      class E
+        include Base
+        include Operator::General
+      end
+
+      class Sin
+        include Base
+        include Operator::General
+      end
+
+      class Cos
+        include Base
+        include Operator::General
+      end
+
+      class Tan
+        include Base
+        include Operator::General
+      end
+
+      class Log
+        include Base
+        include Operator::General
+      end
+
+      class Log10
+        include Base
+        include Operator::General
+      end
+
+      class Log2
+        include Base
+        include Operator::General
+      end
+
+      Symbol.class_eval do
+        include Base
+        include Operator::General
+      end
+
+      numeric_proc = Proc.new do
+        include Helper
+
+        def subst(_hash = {})
+          self
+        end
+
+        def differentiate(_sym = :x)
+          e0
+        end
+        alias_method :d, :differentiate
+
+        alias_method :addition, :+
+        alias_method :subtraction, :-
+        alias_method :multiplication, :*
+        alias_method :division, :/
+        alias_method :exponentiation, :**
+        alias_method :modulation, :%
+
+        ope_to_str = {
+          addition: :+,
+          subtraction: :-,
+          multiplication: :*,
+          division: :/,
+          exponentiation: :**,
+          modulation: :%
+        }
+        %w(+ - * / ** %).each do |operator|
+          define_method(operator) do |g|
+            if g.is_a?(Symbol) ||
+              g.is_a?(Formula) ||
+              g.is_a?(Base)
+
+              _(self).send(operator.to_sym, g)
+            else
+              send(ope_to_str.key(operator.to_sym), g)
+            end
+          end
+        end
+        if self == Rational
+          def to_s
+            "( #{numerator} / #{denominator} )"
+          end
         end
       end
 
+      Float.class_eval(&numeric_proc)
+      Fixnum.class_eval(&numeric_proc)
+      Rational.class_eval(&numeric_proc)
+
+      def e0
+        eval('$e0 ||= _(0)')
+      end
+
+      def e1
+        eval('$e1 ||= _(1)')
+      end
+
       def pi
         $pi ||= Pi.new
       end
@@ -40,14 +217,15 @@ module Dydx
         Float::INFINITY
       end
 
+      # TODO: Method has too many lines. [13/10]
       def log(formula)
-        if formula.multiplication?
+        if formula.formula?(:*)
           f, g = formula.f, formula.g
           log(f) + log(g)
-        elsif formula.exponentiation?
+        elsif formula.formula?(:**)
           f, g = formula.f, formula.g
           g * log(f)
-        elsif formula.is_1?
+        elsif formula.one?
           e0
         elsif formula.is_a?(E)
           e1
@@ -56,28 +234,87 @@ module Dydx
         end
       end
 
-      def sin(x)
-        multiplier = x.is_multiple_of(pi)
-        if multiplier.is_a?(Num)
+      def log2(formula)
+        # TODO: refactor with log function.
+        if formula.formula?(:*)
+          f, g = formula.f, formula.g
+          log2(f) + log2(g)
+        elsif formula.formula?(:**)
+          f, g = formula.f, formula.g
+          g * log2(f)
+        elsif formula.one?
           e0
+        elsif formula.is_a?(Num)
+          (formula.n == 2) ? e1 : log2(formula.n)
+        elsif formula == 2
+          e1
         else
-          Sin.new(x)
+          Log2.new(formula)
         end
       end
 
-      def cos(x)
-        multiplier = x.is_multiple_of(pi)
-        if multiplier.is_a?(Num) && multiplier.n % 2 == 0
+      def log10(formula)
+        # TODO: refactor with log function.
+        if formula.formula?(:*)
+          f, g = formula.f, formula.g
+          log10(f) + log10(g)
+        elsif formula.formula?(:**)
+          f, g = formula.f, formula.g
+          g * log10(f)
+        elsif formula.one?
+          e0
+        elsif formula.is_a?(Num)
+          (formula.n == 10) ? e1 : log10(formula.n)
+        elsif formula == 10
           e1
-        elsif multiplier.is_a?(Num) && multiplier.n % 2 == 1
-          _(-1)
         else
-          Cos.new(x)
+          Log10.new(formula)
+        end
+      end
+
+      # TODO: We should negative num
+      def sin(x)
+        return Sin.new(x) unless x.multiple_of?(pi) && (x / pi).num?
+
+        radn = (x / pi)
+        loop do
+          break if radn < 2
+          radn -= 2
+        end
+
+        case radn
+        when 0        then 0
+        when _(1) / 2 then 1
+        when 1        then 0
+        when _(3) / 2 then -1
+        else               Sin.new(x)
+        end
+      end
+
+      def cos(x)
+        return Cos.new(x) unless x.multiple_of?(pi) && (x / pi).num?
+
+        radn = (x / pi)
+        loop do
+          break if radn < 2
+          radn -= 2
+        end
+
+        case radn
+        when 0        then 1
+        when _(1) / 2 then 0
+        when 1        then -1
+        when _(3) / 2 then 0
+        else               Sin.new(x)
         end
       end
 
       def tan(x)
-        Tan.new(x)
+        if x == 0
+          0
+        else
+          Tan.new(x)
+        end
       end
     end
   end