dydx 0.1.4 → 0.1.25

data/lib/dydx/algebra/formula.rb

@@ -2,44 +2,24 @@ module Dydx
   module Algebra
     class Formula
       include Helper
-      attr_accessor :operator, :terms
+      attr_accessor :f, :operator, :g
 
-      def initialize(operator, *terms)
-        @operator, @terms = operator, terms
-        commutate! if (terms[1].num? && operator.commutative?)
+      def initialize(f, g, operator)
+        @f, @g, @operator = f, g, operator
       end
 
-      def f
-        @terms[0]
-      end
-
-      def g
-        @terms[1]
-      end
-
-      def f=(x)
-        @terms[0] = x
-      end
-
-      def g=(x)
-        @terms[1] = x
-      end
-
-      def trs
-        terms
-      end
-
-      # TODO: Cylomatic complexity for differentiate is too high. [7/6]
-      def differentiate(sym = :x)
+      def differentiate(sym=:x)
         case @operator
-        when :+ then f.d(sym) + g.d(sym)
-        when :* then (f.d(sym) * g) + (f * g.d(sym))
-        when :**
+        when :+
+          f.d(sym) + g.d(sym)
+        when :*
+          (f.d(sym) * g) + (f * g.d(sym))
+        when :^
           # TODO:
-          if g.num?
-            f.d(sym) * g * (f ** (g - 1))
+          if g.is_num?
+            f.d(sym) * g * (f ^ (g - 1) )
           elsif f == sym
-            g * (f ** (g - 1))
+            g * (f ^ (g - 1))
           elsif f == e
             g.d(sym) * self
           else
@@ -50,29 +30,21 @@ module Dydx
       alias_method :d, :differentiate
 
       def to_s
-        if formula?(:*) && (f.minus1? || g.minus1?)
-          "( - #{g} )"
-        elsif g.inverse?(operator)
-          "( #{f} #{operator.inv} #{g.x} )"
-        elsif f.inverse?(operator)
-          "( #{g} #{operator.inv} #{f.x} )"
-        elsif formula?(:*) && !rationals.empty?
-          terms = [f, g]
-          terms.delete(rationals.first)
-          "( #{(terms.first * rationals.first.n.numerator)} / #{rationals.first.n.denominator} )"
+        if (multiplication? && (f.is_minus1? || g.is_minus1?)  )
+          "( - #{g.to_s} )"
+        elsif multiplication? && g.inverse?(:*)
+          "( #{f.to_s} / #{g.x.to_s} )"
+        elsif multiplication? && f.inverse?(:*)
+          "( #{g.to_s} / #{f.x.to_s} )"
+        elsif addition? && g.inverse?(:+)
+          "( #{f.to_s} - #{g.x.to_s} )"
+        elsif addition? && f.inverse?(:+)
+          "( #{g.to_s} - #{f.x.to_s} )"
         else
-          "( #{f} #{operator} #{g} )"
+          "( #{f.to_s} #{@operator} #{g.to_s} )"
         end
       end
 
-      def subst(hash = {})
-        f.subst(hash).send(operator, g.subst(hash))
-      end
-
-      def to_f
-        f.to_f.send(operator, g.to_f)
-      end
-
       def include?(x)
         f == x || g == x
       end
@@ -82,33 +54,28 @@ module Dydx
         (f.combinable?(x, operator) || g.combinable?(x, operator))
       end
 
-      def rationals
-        [f, g].select{ |term| term.num? && term.n.is_a?(Rational) }
-      end
-
+      # TODO: interchangeable
       def ==(x)
-        if to_s == x.to_s
-          true
-        else
-          result = commutate!.to_s == x.to_s
-          commutate!
-          result
+        to_s == x.to_s
+      end
+
+      def common_factors(formula)
+        nil unless formula.is_a?(Formula)
+        if f == formula.f
+          [:f, :f]
+        elsif g == formula.g
+          [:g, :g]
+        elsif f == formula.g
+          [:f, :g]
+        elsif g == formula.f
+          [:g, :f]
         end
       end
 
       def commutate!
-        @terms.reverse!
+        @f, @g = @g, @f
         self
       end
-
-      def index(tr)
-        trs.index(tr)
-      end
-
-      def delete(tr)
-        trs.delete(tr)
-        trs.count.one? ? trs.first : self
-      end
     end
   end
 end

data/lib/dydx/algebra/inverse.rb

@@ -9,35 +9,28 @@ module Dydx
       end
 
       def to_s
+        # sym = {'*'=>'/', '+'=>'-'}[operator.to_s]
         case operator
-        when :+ then "( - #{x} )"
-        when :* then "( 1 / #{x} )"
-        end
-      end
-
-      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
+        when :+
+          "( - #{x} )"
+        when :*
+          "( 1 / #{x} )"
         end
       end
 
-      def differentiate(sym = :x)
+      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
+
+      def ==(x)
+        to_s == x.to_s
+      end
     end
   end
-end
+end

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

@@ -0,0 +1,3 @@
+require 'dydx/algebra/operator/parts/base'
+require 'dydx/algebra/operator/parts/general'
+require 'dydx/algebra/operator/parts/interface'

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

@@ -1,3 +1,6 @@
+require 'dydx/algebra/operator/common_parts'
+require 'dydx/algebra/operator/parts/formula'
+
 module Dydx
   module Algebra
     module Operator
@@ -5,6 +8,7 @@ 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,9 +1,13 @@
+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,3 +1,6 @@
+require 'dydx/algebra/operator/common_parts'
+require 'dydx/algebra/operator/parts/inverse'
+
 module Dydx
   module Algebra
     module Operator
@@ -5,6 +8,7 @@ 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,3 +1,6 @@
+require 'dydx/algebra/operator/common_parts'
+require 'dydx/algebra/operator/parts/num'
+
 module Dydx
   module Algebra
     module Operator
@@ -5,6 +8,7 @@ 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(operator.to_sym, self, x)
+              ::Algebra::Formula.new(self, x, operator.to_sym)
             end
           end
         end

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

@@ -3,82 +3,57 @@ module Dydx
     module Operator
       module Parts
         module Formula
-          %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]
-                  )
+          %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)
                 else
-                  super(rtr)
+                  super(x)
                 end
-              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
+              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)
 
-                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
-                    )
+                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!
                   end
                 end
-              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
+              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)
 
-                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
-                    )
+                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!
                   end
                 end
               else
-                super(rtr)
+                super(x)
               end
             end
           end
 
-          %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(rtr)
-              end
+          def ^(x)
+            if multiplication? && openable?(:^, x)
+              (f ^ x).send(self.operator, (g ^ x))
+            else
+              super(x)
             end
           end
         end

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

@@ -2,108 +2,55 @@ module Dydx
   module Algebra
     module Operator
       module Parts
-        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|
+        module General
+          %w(+ * ^).map(&:to_sym).each do |operator|
             define_method(operator) do |x|
-              if x.zero?
+              if x.is_0?
                 case operator
-                when :+  then self
-                when :*  then x
-                when :** then e1
+                when :+ then self
+                when :* then x
+                when :^ then e1
                 end
-              elsif x.one?
+              elsif x.is_1?
                 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 inverse?(operator, x)
-                case operator
-                when :+ then e0
-                when :* then e1
+              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)
                 end
-              elsif [:+, :*].include?(operator)
-                if x.formula?(operator.super) && self == x.f
-                  send(operator.super, (1 + x.g))
+              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
+              elsif [:*].include?(operator) && x.inverse?(:+)
+                inverse(::Algebra::Formula.new(self, x.x, operator.to_sym), :+)
               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)
-              end
-            end
-          end
-        end
-
-        module General
-          include General2
-          include General1
-          include Associative
-          include Interface
-        end
       end
     end
   end