dydx 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 07dd79c6718aec02bcbe4274cedadc700d694743
-  data.tar.gz: f94746b938d94132d40a24cbb65087f2f2a28ff9
+  metadata.gz: 50b217dcece3200df260f85267cc8eb9962327d1
+  data.tar.gz: c1f0fad073894322d1fe70198ad12ec81eeb7fc3
 SHA512:
-  metadata.gz: ea77ed0736af837a9294b2baa9f6d63d50aa8d2dcd146a17e55fa9ad3fcf49574ba30c10ffb2998618c88a1cf6e0b7e652b8b5d406d514477b971aa7059664d7
-  data.tar.gz: 92c7a5a3fd45764282792b665591f5016a796a2466d0ea5388136f3d80259877a62ff7ec497b5f1eeaaa40605da443b3a3eb056421770784e7a22df3f287e248
+  metadata.gz: 20a5be7e5853dbb70910c8595a509a903882a58d7393bffe44d809e37d38910aefbe17024bd82c27e6ed1084895cdd1d74dc0765a033d852f3d4187d1b8e12a1
+  data.tar.gz: bcb0c305f6d9befd7de5b1c415bf522c012adfb910fe4707efdaeaf745d3cdb1391c64f6ea3e94f7e39d29c8e5369a12626c0b4eb57f48bdad18bf4f1372ed07

data/lib/dydx/algebra.rb

@@ -48,6 +48,8 @@ module Dydx
         e0
       elsif operator == :* && x.is_1?
         e1
+      elsif x.is_a?(Inverse) && x.operator == operator
+        x.x
       else
         Inverse.new(x, operator)
       end

data/lib/dydx/algebra/formula.rb

@@ -51,9 +51,28 @@ module Dydx
         x.is_num? && (f.is_num? || g.is_num?)
       end
 
+      # TODO: interchangeable
       def ==(x)
         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!
+        @f, @g = @g, @f
+        self
+      end
     end
   end
 end

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

@@ -5,36 +5,9 @@ module Dydx
         module Base
           %w(+ * ^).map(&:to_sym).each do |operator|
             define_method(operator) do |x|
-              if self == x && operator != :^
-                case operator
-                when :+
-                  _(2) * self
-                when :*
-                  self ^ _(2)
-                end
-              elsif %w(+ *).map(&:to_sym).include?(operator) && x.send("#{to_str(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
-                  ::Algebra::Formula.new(self, x, operator.to_sym)
-                end
-              elsif x.subtrahend? && %w(* ^).map(&:to_sym).include?(operator)
-                inverse(::Algebra::Formula.new(self, x.x, operator.to_sym), :+)
-              else
-                ::Algebra::Formula.new(self, x, operator.to_sym)
-              end
+              ::Algebra::Formula.new(self, x, operator.to_sym)
             end
           end
-
-          def to_str(operator)
-            {
-              addition:       :+,
-              multiplication: :*,
-              exponentiation: :^
-            }.key(operator)
-          end
         end
       end
     end

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

@@ -13,66 +13,34 @@ module Dydx
                 else
                   super(x)
                 end
-              elsif operator == :+
-                if multiplication? && x.multiplication?
-                  if f == x.f
-                    f * g.send(operator, x.g)
-                  elsif f == x.g
-                    f * g.send(operator, x.f)
-                  elsif g == x.f
-                    f.send(operator, x.g) * g
-                  elsif g == x.g
-                    f.send(operator, x.f) * g
-                  else
-                    super(x)
+              elsif send("#{to_str(super_ope(operator))}?") && x.send("#{to_str(super_ope(operator))}?")
+                return super(x) if !common_factors(x) || (operator == :* && common_factors(x)[0] != common_factors(x)[1])
+                w1, w2 = common_factors(x)
+                case operator
+                when :+
+                  send(w1).send(super_ope(operator), send(rest(w1)).send(operator, x.send(rest(w2))))
+                when :*
+                  if w1 == :f
+                    send(w1).send(super_ope(operator), send(rest(w1)).send(sub_ope(operator), x.send(rest(w2))))
+                  elsif w1 == :g
+                    send(w1).send(super_ope(operator), send(rest(w1)).send(operator, x.send(rest(w2)))).commutate!
                   end
-                # expect(((:b * :a) - (:c * :a)).to_s).to eq('( ( b - c ) * a )')
-                elsif multiplication? && x.subtrahend? && x.x.multiplication?
-                  if f == x.x.f
-                    f * g.send(operator, inverse(x.x.g, :+))
-                  elsif f == x.x.g
-                    f * g.send(operator, inverse(x.x.f, :+))
-                  elsif g == x.x.f
-                    f.send(operator, inverse(x.x.g, :+)) * g
-                  elsif g == x.x.g
-                    f.send(operator, inverse(x.x.f, :+)) * g
-                  else
-                    super(x)
-                  end
-                else
-                  super(x)
                 end
-              elsif operator == :*
-                if exponentiation? && x.exponentiation?
-                  if f == x.f
-                    f ^ g.send(:+, x.g)
-                  elsif g == x.g
-                    f.send(operator, x.f) ^ g
-                  else
-                    super(x)
-                  end
-                elsif exponentiation? && x.divisor? && x.x.exponentiation?
-                  if f == x.x.f
-                    f ^ g.send(:-, x.x.g)
-                  elsif g == x.x.g
-                    f.send(:/, x.x.f) ^ g
-                  else
-                    super(x)
+              elsif send("#{to_str(super_ope(operator))}?") && x.send("#{to_str_inv(operator)}?") && x.x.send("#{to_str(super_ope(operator))}?")
+                return super(x) if !common_factors(x.x) || (operator == :* && common_factors(x.x)[0] != common_factors(x.x)[1])
+                w1, w2 = common_factors(x.x)
+                case operator
+                when :+
+                  send(w1).send(super_ope(operator), send(rest(w1)).send(inverse_ope(operator), x.x.send(rest(w2))))
+                when :*
+                  if w1 == :f
+                    send(w1).send(super_ope(operator), send(rest(w1)).send(inverse_ope(sub_ope(operator)), x.x.send(rest(w2))))
+                  elsif w1 == :g
+                    send(w1).send(super_ope(operator), send(rest(w1)).send(inverse_ope(operator), x.x.send(rest(w2)))).commutate!
                   end
-                # x * inverse(:y, :+)
-                elsif x.subtrahend?
-                  inverse(self * x.x, :+)
-                elsif multiplication?
-                  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(x)
-                  end
-                else
-                  super(x)
                 end
+              else
+                super(x)
               end
             end
           end
@@ -92,6 +60,17 @@ module Dydx
               exponentiation: :^
             }.key(operator)
           end
+
+          def to_str_inv(operator)
+            {
+              subtrahend: :+,
+              divisor:    :*
+            }.key(operator)
+          end
+
+          def rest(f_or_g)
+            ([:f, :g] - [f_or_g]).first
+          end
         end
       end
     end

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

@@ -3,36 +3,60 @@ module Dydx
     module Operator
       module Parts
         module General
-          def +(x)
-            if x.is_0?
-              self
-            elsif inverse?(x, :+)
-              e0
-            else
-              super(x)
+          %w(+ * ^).map(&:to_sym).each do |operator|
+            define_method(operator) do |x|
+              if x.is_0?
+                case operator
+                when :+ then self
+                when :* then x
+                when :^ then e1
+                end
+              elsif x.is_1?
+                case operator
+                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)
+                end
+              elsif operator == :+ && inverse?(x, :+)
+                e0
+              elsif operator == :* && inverse?(x, :*)
+                e1
+              elsif [:+, :*].include?(operator) && x.send("#{to_str(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.send("#{to_str(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.subtrahend?
+                inverse(::Algebra::Formula.new(self, x.x, operator.to_sym), :+)
+              else
+                super(x)
+              end
             end
           end
 
-          def *(x)
-            if x.is_0?
-              x
-            elsif x.is_1?
-              self
-            elsif inverse?(x, :*)
-              e1
-            else
-              super(x)
-            end
-          end
-
-          def ^(x)
-            if x.is_0?
-              _(1)
-            elsif x.is_1?
-              self
-            else
-              super(x)
-            end
+          def to_str(operator)
+            {
+              addition:       :+,
+              multiplication: :*,
+              exponentiation: :^
+            }.key(operator)
           end
         end
       end

data/lib/dydx/helper.rb

@@ -84,6 +84,26 @@ module Dydx
       end
     end
 
+    def sub_ope(operator)
+      case operator
+      when :*
+        :+
+      end
+    end
+
+    def inverse_ope(operator)
+      case operator
+      when :+
+        :-
+      when :*
+        :/
+      end
+    end
+
+    def commutative?(operator)
+      [:+, :*].include?(operator)
+    end
+
     def inverse?(x, operator)
       if is_a?(Algebra::Inverse)
         self.operator == operator && self.x == x

data/lib/dydx/version.rb

@@ -1,3 +1,3 @@
 module Dydx
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/spec/lib/algebra/operator/parts/formula_spec.rb

@@ -2,27 +2,54 @@ require 'spec_helper'
 
 describe Dydx::Algebra::Operator::Parts::Formula do
   it{ expect(((:a * :b) + (:a * :c)).to_s).to eq('( a * ( b + c ) )') }
-  it{ expect(((:b * :a) + (:c * :a)).to_s).to eq('( ( b + c ) * a )') }
+  it{ expect(((:a * :b) + (:c * :a)).to_s).to eq('( a * ( b + c ) )') }
+  it{ expect(((:b * :a) + (:c * :a)).to_s).to eq('( a * ( b + c ) )') }
+  it{ expect(((:b * :a) + (:a * :c)).to_s).to eq('( a * ( b + c ) )') }
   it{ expect(((:a * :b) - (:a * :c)).to_s).to eq('( a * ( b - c ) )') }
-  it{ expect(((:b * :a) - (:c * :a)).to_s).to eq('( ( b - c ) * a )') }
+  it{ expect(((:a * :b) - (:c * :a)).to_s).to eq('( a * ( b - c ) )') }
+  it{ expect(((:b * :a) - (:c * :a)).to_s).to eq('( a * ( b - c ) )') }
+  it{ expect(((:b * :a) - (:a * :c)).to_s).to eq('( a * ( b - c ) )') }
 
-  it{ expect(((:x ^ 3) * (:x ^ 2)).to_s).to eq('( x ^ 5 )') }
-  it{ expect(((:x ^ 3) / (:x ^ 2)).to_s).to eq('x') }
-  it{ expect(((:x ^ :n) * (:y ^ :n)).to_s).to eq('( ( x * y ) ^ n )') }
-  it{ expect(((:x ^ :n) / (:y ^ :n)).to_s).to eq('( ( x / y ) ^ n )') }
+  it{ expect(((:a ^ :b) * (:a ^ :c)).to_s).to eq('( a ^ ( b + c ) )') }
+  it{ expect(((:a ^ :b) * (:c ^ :a)).to_s).to eq('( ( a ^ b ) * ( c ^ a ) )') }
+  it{ expect(((:b ^ :a) * (:c ^ :a)).to_s).to eq('( ( b * c ) ^ a )') }
+  it{ expect(((:b ^ :a) * (:a ^ :c)).to_s).to eq('( ( b ^ a ) * ( a ^ c ) )') }
+  it{ expect(((:a ^ :b) / (:a ^ :c)).to_s).to eq('( a ^ ( b - c ) )') }
+  it{ expect(((:a ^ :b) / (:c ^ :a)).to_s).to eq('( ( a ^ b ) / ( c ^ a ) )') }
+  it{ expect(((:b ^ :a) / (:c ^ :a)).to_s).to eq('( ( b / c ) ^ a )') }
+  it{ expect(((:b ^ :a) / (:a ^ :c)).to_s).to eq('( ( b ^ a ) / ( a ^ c ) )') }
 
   it{ expect(((:x - 2) + 2).to_s).to eq('x') }
   it{ expect(((:x + 2) - 2).to_s).to eq('x') }
   it{ expect(((:x * 2) / 2).to_s).to eq('x') }
   it{ expect(((:x / 2) * 2).to_s).to eq('x') }
 
+  it{ expect((2 + (:x - 2)).to_s).to eq('x') }
+  it{ expect((2 - (:x + 2)).to_s).to eq('( - x )') }
+  it{ expect((2 * (:x / 2)).to_s).to eq('x') }
+  it{ expect((2 / (:x * 2)).to_s).to eq('( 1 / x )') }
+
   it{ expect(((:x + :y) + :y).to_s).to eq('( ( 2 * y ) + x )') }
+  it{ expect(((:y + :x) + :y).to_s).to eq('( ( 2 * y ) + x )') }
   it{ expect(((:x - :y) - :y).to_s).to eq('( x - ( 2 * y ) )') }
   it{ expect(((:y - :x) - :y).to_s).to eq('( - x )') }
+  it{ expect(((:y * :x) * :y).to_s).to eq('( ( y ^ 2 ) * x )') }
   it{ expect(((:x * :y) * :y).to_s).to eq('( ( y ^ 2 ) * x )') }
   it{ expect(((:x / :y) / :y).to_s).to eq('( x / ( y ^ 2 ) )') }
   it{ expect(((:y / :x) / :y).to_s).to eq('( 1 / x )') }
 
+  it{ expect((:y + (:x + :y)).to_s).to eq('( ( 2 * y ) + x )') }
+  it{ expect((:y + (:y + :x)).to_s).to eq('( ( 2 * y ) + x )') }
+  it{ expect((:y - (:x - :y)).to_s).to eq('( ( 2 * y ) - x )') }
+  it{ expect((:y - (:y - :x)).to_s).to eq('x') }
+  it{ expect((:y * (:y * :x)).to_s).to eq('( ( y ^ 2 ) * x )') }
+  it{ expect((:y * (:x * :y)).to_s).to eq('( ( y ^ 2 ) * x )') }
+  it{ expect((:y - (:x - :y)).to_s).to eq('( ( 2 * y ) - x )') }
+  it{ expect((:y - (:y - :x)).to_s).to eq('x') }
+
   it{ expect(((:x * 2) ^ 2).to_s).to eq('( ( x ^ 2 ) * 4 )') }
   it{ expect(((:x / 2) ^ 2).to_s).to eq('( ( x ^ 2 ) / 4 )') }
+
+  it{ expect((2 ^ (:x * 2)).to_s).to eq('( ( x ^ 2 ) * 4 )') }
+  it{ expect((2 ^ (:x / 2)).to_s).to eq('( ( x ^ 2 ) / 4 )') }
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dydx
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - gogotanaka