dydx 0.0.4 → 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 07dd79c6718aec02bcbe4274cedadc700d694743
+  data.tar.gz: f94746b938d94132d40a24cbb65087f2f2a28ff9
+SHA512:
+  metadata.gz: ea77ed0736af837a9294b2baa9f6d63d50aa8d2dcd146a17e55fa9ad3fcf49574ba30c10ffb2998618c88a1cf6e0b7e652b8b5d406d514477b971aa7059664d7
+  data.tar.gz: 92c7a5a3fd45764282792b665591f5016a796a2466d0ea5388136f3d80259877a62ff7ec497b5f1eeaaa40605da443b3a3eb056421770784e7a22df3f287e248

data/lib/dydx/algebra.rb

@@ -1,7 +1,9 @@
 require 'dydx/algebra/formula'
+require 'dydx/algebra/inverse'
 
 require 'dydx/algebra/set'
 
+require 'dydx/algebra/operator/inverse'
 require 'dydx/algebra/operator/formula'
 require 'dydx/algebra/operator/symbol'
 require 'dydx/algebra/operator/num'
@@ -39,5 +41,16 @@ module Dydx
       class Tan;    include Operator::General; end
     end
     class Formula;  include Operator::Formula; end
+    class Inverse;  include Operator::Inverse; end
+
+    def inverse(x, operator)
+      if operator == :+ && x.is_0?
+        e0
+      elsif operator == :* && x.is_1?
+        e1
+      else
+        Inverse.new(x, operator)
+      end
+    end
   end
 end

data/lib/dydx/algebra/formula.rb

@@ -12,16 +12,14 @@ module Dydx
         case @operator
         when :+
           f.d(sym) + g.d(sym)
-        when :-
-          f.d(sym) - g.d(sym)
         when :*
           (f.d(sym) * g) + (f * g.d(sym))
-        when :/
-          ((f.d(sym) * g) - (f * g.d(sym)))/(g ^ _(2))
         when :^
           # TODO:
           if f == sym
             g * (f ^ (g - 1))
+          elsif f == e
+            g.d(sym) * self
           else
             self * (g * log(f)).d(sym)
           end
@@ -30,9 +28,16 @@ module Dydx
       alias_method :d, :differentiate
 
       def to_s
-        if (subtraction? && f.is_0?) ||
-          (multiplication? && (f.is_minus1? || g.is_minus1?)  )
+        if (multiplication? && (f.is_minus1? || g.is_minus1?)  )
           "( - #{g.to_s} )"
+        elsif multiplication? && g.divisor?
+          "( #{f.to_s} / #{g.x.to_s} )"
+        elsif multiplication? && f.divisor?
+          "( #{g.to_s} / #{f.x.to_s} )"
+        elsif addition? && g.subtrahend?
+          "( #{f.to_s} - #{g.x.to_s} )"
+        elsif addition? && f.subtrahend?
+          "( #{g.to_s} - #{f.x.to_s} )"
         else
           "( #{f.to_s} #{@operator} #{g.to_s} )"
         end
@@ -41,6 +46,14 @@ module Dydx
       def include?(x)
         f == x || g == x
       end
+
+      def openable?(x)
+        x.is_num? && (f.is_num? || g.is_num?)
+      end
+
+      def ==(x)
+        to_s == x.to_s
+      end
     end
   end
 end

data/lib/dydx/algebra/inverse.rb

@@ -0,0 +1,36 @@
+module Dydx
+  module Algebra
+    class Inverse
+      include Helper
+      attr_accessor :x, :operator
+
+      def initialize(x, operator)
+        @x, @operator = x, operator
+      end
+
+      def to_s
+        # sym = {'*'=>'/', '+'=>'-'}[operator.to_s]
+        case operator
+        when :+
+          "( - #{x} )"
+        when :*
+          "( 1 / #{x} )"
+        end
+      end
+
+      def differentiate(sym=:x)
+        case operator
+        when :+
+          inverse(x.differentiate(sym), :+)
+        when :*
+          inverse(x.differentiate(sym) * inverse(x ^ 2, :*), :+)
+        end
+      end
+      alias_method :d, :differentiate
+
+      def ==(x)
+        to_s == x.to_s
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'dydx/algebra/operator/common_parts'
+require 'dydx/algebra/operator/parts/inverse'
+
+module Dydx
+  module Algebra
+    module Operator
+      module Inverse
+        include Parts::Base
+        include Parts::Inverse
+        include Parts::General
+        include Parts::Interface
+      end
+    end
+  end
+end

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

@@ -3,24 +3,38 @@ module Dydx
     module Operator
       module Parts
         module Base
-          %w(+ - * / ^).each do |operator|
+          %w(+ * ^).map(&:to_sym).each do |operator|
             define_method(operator) do |x|
-              if self == x && operator != '^'
+              if self == x && operator != :^
                 case operator
-                when '+'
+                when :+
                   _(2) * self
-                when '-'
-                  _(0)
-                when '*'
+                when :*
                   self ^ _(2)
-                when '/'
-                  _(1)
                 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
             end
           end
+
+          def to_str(operator)
+            {
+              addition:       :+,
+              multiplication: :*,
+              exponentiation: :^
+            }.key(operator)
+          end
         end
       end
     end

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

@@ -3,61 +3,95 @@ module Dydx
     module Operator
       module Parts
         module Formula
-          %w(+ -).map(&:to_sym).each do |operator|
+          %w(+ *).map(&:to_sym).each do |operator|
             define_method(operator) do |x|
-              if multiplication? && x.multiplication?
-                if f == x.f
-                  f * g.send(operator, x.g)
-                elsif g == x.g
-                  f.send(operator, x.f) * g
+              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(x)
                 end
-              elsif ([self.operator, operator].sort == [:+, :-]) &&  include?(x)
-                if f == x
-                  g
-                elsif g == x
-                  f
+              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)
+                  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 (self.operator == operator) && include?(x)
-                if f == x
-                  f.send(operator, x).send(operator, g)
-                elsif g == x
-                  f.send(operator, g.send(:+, x))
+              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)
+                  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
 
-          %w(* /).map(&:to_sym).each do |operator|
-            define_method(operator) do |x|
-              if exponentiation? && x.exponentiation?
-                if f == x.f
-                  f ^ g.send({'*'=>'+', '/'=>'-'}[operator.to_s], x.g)
-                elsif g == x.g
-                  f.send(operator, x.f) ^ g
-                else
-                  super(x)
-                end
-              elsif ([self.operator, operator].sort == [:*, :/]) &&  include?(x)
-                if f == x
-                  g
-                elsif g == x
-                  f
-                end
-              elsif (self.operator == operator) && include?(x)
-                if f == x
-                  f.send(operator, x).send(operator, g)
-                elsif g == x
-                  f.send(operator, g.send(:* , x))
-                end
-              else
-                super(x)
-              end
+          def ^(x)
+            if multiplication? && openable?(x)
+              (f ^ x).send(self.operator, (g ^ x))
+            else
+              super(x)
             end
           end
+
+          def to_str(operator)
+            {
+              addition:       :+,
+              multiplication: :*,
+              exponentiation: :^
+            }.key(operator)
+          end
         end
       end
     end

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

@@ -6,14 +6,8 @@ module Dydx
           def +(x)
             if x.is_0?
               self
-            else
-              super(x)
-            end
-          end
-
-          def -(x)
-            if x.is_0?
-              self
+            elsif inverse?(x, :+)
+              e0
             else
               super(x)
             end
@@ -24,16 +18,8 @@ module Dydx
               x
             elsif x.is_1?
               self
-            else
-              super(x)
-            end
-          end
-
-          def /(x)
-            if x.is_0?
-              raise ZeroDivisionError
-            elsif x.is_1?
-              self
+            elsif inverse?(x, :*)
+              e1
             else
               super(x)
             end

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

@@ -3,10 +3,18 @@ module Dydx
     module Operator
       module Parts
         module Interface
-          %w(+ - * / ^).each do |operator|
+          %w(+ - * / ^).map(&:to_sym).each do |operator|
             define_method(operator) do |x|
               x = ::Set::Num.new(x) if x.is_a?(Fixnum)
-              super(x)
+              case operator
+              when :-
+                self + inverse(x, :+)
+              when :/
+                raise ZeroDivisionError if x.is_0?
+                self * inverse(x, :*)
+              else
+                super(x)
+              end
             end
           end
         end

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

@@ -0,0 +1,36 @@
+module Dydx
+  module Algebra
+    module Operator
+      module Parts
+        module Inverse
+          def +(x)
+            if self.x == x && operator == :+
+              e0
+            elsif !x.is_a?(Inverse)
+              x + self
+            else
+              super(x)
+            end
+          end
+
+          def *(x)
+            if self.x == x && operator == :*
+              e1
+            else
+              super(x)
+            end
+          end
+
+          def ^(x)
+            case operator
+            when :+
+              super(x)
+            when :*
+              inverse(self.x ^ x, :*)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,14 +8,8 @@ module Dydx
               x
             elsif x.is_a?(Num)
               _(n + x.n)
-            else
-              super(x)
-            end
-          end
-
-          def -(x)
-            if x.is_a?(Num)
-              _(n - x.n)
+            elsif x.subtrahend? && x.x.is_a?(Num)
+              _(n - x.x.n)
             else
               super(x)
             end
@@ -28,14 +22,8 @@ module Dydx
               x
             elsif x.is_a?(Num)
               _(n * x.n)
-            else
-              super(x)
-            end
-          end
-
-          def /(x)
-            if (n == 0)
-              self
+            elsif x.divisor? && x.x.is_a?(Num)
+              _(n / x.x.n)
             else
               super(x)
             end

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

@@ -12,16 +12,6 @@ module Dydx
               super(x)
             end
           end
-
-          def /(x)
-            if x.exponentiation? &&
-              self == x.f
-
-              self ^ (1 - x.g)
-            else
-              super(x)
-            end
-          end
         end
       end
     end

data/lib/dydx/algebra/set.rb

@@ -12,6 +12,13 @@ require 'dydx/algebra/set/tan'
 module Dydx
   module Algebra
     module Set
+      def e0
+        eval("$e0 ||= Num.new(0)")
+      end
+
+      def e1
+        eval("$e1 ||= Num.new(1)")
+      end
       def _(num)
         if num >= 0
           eval("$p#{num} ||= Num.new(num)")

data/lib/dydx/helper.rb

@@ -1,17 +1,50 @@
 module Dydx
   module Helper
+    OP_SYM_STR = {
+      addition:       :+,
+      subtraction:    :-,
+      multiplication: :*,
+      exponentiation: :^
+    }
+
     def is_0?
-      self == 0 || (is_a?(Num) && n == 0)
+      self == 0 || (is_a?(Num) && n == 0) || (subtrahend? && x.is_0?)
     end
 
     def is_1?
-      self == 1 || (is_a?(Num) && n == 1)
+      self == 1 || (is_a?(Num) && n == 1) || (divisor? && x.is_1?)
     end
 
     def is_minus1?
       self == -1 || (is_a?(Num) && n == -1)
     end
 
+    def is_num?
+      if is_a?(Inverse)
+        x.is_num?
+      else
+        is_a?(Num) || is_a?(Fixnum)
+      end
+    end
+
+    def combinable?(x, operator)
+      case operator
+      when :*
+        self == x ||
+        (is_num? && x.is_num?) ||
+        inverse?(x, :*)
+      when :+
+        like_term?(x)
+      end
+    end
+
+    def like_term?(x)
+      self == x ||
+      (is_num? && x.is_num?) ||
+      (multiplication? && (f == x || g == x)) ||
+      inverse?(x, :+)
+    end
+
     def is_multiple_of(x)
       is_multiple = if is_0?
         _(0)
@@ -25,14 +58,48 @@ module Dydx
       end
     end
 
-    {
-      addition:       :+,
-      subtraction:    :-,
-      multiplication: :*,
-      division:       :/,
-      exponentiation: :^
-    }.each do |operator_name, operator|
-      define_method("#{operator_name}?") { @operator == operator }
+    OP_SYM_STR.each do |operator_name, operator|
+      define_method("#{operator_name}?") do
+        (@operator == operator) && is_a?(Formula)
+        # is_a?(Inverse) && self.operator == operator
+      end
+    end
+
+    def to_str(sym)
+      OP_SYM_STR.key(sym)
+    end
+
+    def str_to_sym(str)
+      OP_SYM_STR[str]
+    end
+
+    def super_ope(operator)
+      case operator
+      when :+
+        :*
+      when :-
+        :/
+      when :*
+        :^
+      end
+    end
+
+    def inverse?(x, operator)
+      if is_a?(Algebra::Inverse)
+        self.operator == operator && self.x == x
+      elsif x.is_a?(Algebra::Inverse)
+        self == x.x
+      else
+        false
+      end
+    end
+
+    def subtrahend?
+       is_a?(Inverse) && operator == :+
+    end
+
+    def divisor?
+       is_a?(Inverse) && operator == :*
     end
   end
 end

data/lib/dydx/version.rb

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

data/spec/dydx_spec.rb

@@ -28,4 +28,12 @@ describe Dydx do
     it{ expect(d1.to_s).to eq('t') }
     it{ expect(d2.to_s).to eq('t') }
   end
+
+  context 'ex4' do
+    $f = 2 * (e ^ (2 * :z))
+    let(:d1){ df/dz }
+    let(:d2){ d/dz($f) }
+    it{ expect(d1.to_s).to eq('( 4 * ( e ^ ( 2 * z ) ) )') }
+    it{ expect(d2.to_s).to eq('( 4 * ( e ^ ( 2 * z ) ) )') }
+  end
 end

data/spec/lib/algebra/formula_spec.rb

@@ -9,8 +9,8 @@ describe Dydx::Algebra::Formula do
   describe 'Calculate' do
     context 'With Fixnum' do
       let(:formula) { (:x + :y) }
-      it{ expect((formula + 0).to_s).to eq(formula.to_s) }
-      it{ expect((formula - 0).to_s).to eq(formula.to_s) }
+      it{ expect(formula + 0).to eq(formula + 0) }
+      it{ expect(formula - 0).to eq(formula - 0) }
       it{ expect((formula * 0).to_s).to eq('0') }
       it{ expect((formula * 1).to_s).to eq(formula.to_s) }
       it{ expect{(formula / 0).to_s}.to raise_error(ZeroDivisionError) }
@@ -34,15 +34,15 @@ describe Dydx::Algebra::Formula do
     it{ expect(addition.d(:z).to_s).to eq('0') }
 
     it{ expect(subtraction.d(:x).to_s).to eq('1') }
-    it{ expect(subtraction.d(:y).to_s).to eq('-1') }
+    it{ expect(subtraction.d(:y).to_s).to eq('( - 1 )') }
     it{ expect(subtraction.d(:z).to_s).to eq('0') }
 
     it{ expect(multiplication.d(:x)).to eq(:y) }
     it{ expect(multiplication.d(:y)).to eq(:x) }
     it{ expect(multiplication.d(:z).to_s).to eq('0') }
 
-    it{ expect(division.d(:x).to_s).to eq("( y ^ -1 )") }
-    it{ expect(division.d(:y).to_s).to eq('( ( - x ) / ( y ^ 2 ) )') }
+    it{ expect(division.d(:x).to_s).to eq("( 1 / y )") }
+    it{ expect(division.d(:y).to_s).to eq('( - ( x / ( y ^ 2 ) ) )') }
     it{ expect(division.d(:z).to_s).to eq('0') }
 
     it{ expect(exponentiation.d(:x).to_s).to eq('( y * ( x ^ ( y - 1 ) ) )') }
@@ -54,4 +54,9 @@ describe Dydx::Algebra::Formula do
     it{ expect(addition.include?(:x)).to be_true }
     it{ expect(addition.include?(:z)).to be_false }
   end
+
+  describe '#openable?' do
+    it{ expect((1 + :x).openable?(_(1))).to be_true }
+    it{ expect((1 + :x).openable?(:z)).to be_false }
+  end
 end

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

@@ -16,10 +16,13 @@ describe Dydx::Algebra::Operator::Parts::Formula do
   it{ expect(((:x * 2) / 2).to_s).to eq('x') }
   it{ expect(((:x / 2) * 2).to_s).to eq('x') }
 
-  it{ expect(((:x + :y) + :y).to_s).to eq('( x + ( 2 * y ) )') }
+  it{ expect(((:x + :y) + :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(((:x * :y) * :y).to_s).to eq('( x * ( y ^ 2 ) )') }
+  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(((:x * 2) ^ 2).to_s).to eq('( ( x ^ 2 ) * 4 )') }
+  it{ expect(((:x / 2) ^ 2).to_s).to eq('( ( x ^ 2 ) / 4 )') }
 end

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

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Dydx::Algebra::Operator::Parts::Inverse do
+  it{ expect(inverse(:x, :+).to_s).to eq('( - x )') }
+  it{ expect(inverse(:x, :*).to_s).to eq('( 1 / x )') }
+
+  it{ expect(inverse(:x, :+)).to eq(inverse(:x, :+)) }
+  it{ expect(inverse(:x, :*)).to eq(inverse(:x, :*)) }
+
+  it{ expect(:x - :x).to eq(e0) }
+  it{ expect(:x / :x).to eq(e1) }
+  it{ expect(inverse(:x, :+) + :x).to eq(e0) }
+  it{ expect(inverse(:x, :*) * :x).to eq(e1) }
+end

data/spec/lib/algebra/set/num_spec.rb

@@ -3,6 +3,8 @@ require 'spec_helper'
 describe Dydx::Algebra::Set::Num do
   it{ expect(_(1)).to eq(_(1)) }
   it{ expect(_(-1)).to eq(_(-1)) }
+  it{ expect(e0).to eq(e0) }
+  it{ expect(e1).to eq(e1) }
 
   describe '#to_s' do
     it{ expect(_(1).to_s).to eq('1') }

data/spec/lib/helper_spec.rb

@@ -1,22 +1,37 @@
 require 'spec_helper'
 
 describe Helper do
-  it{ expect(0.is_0?).to be_true }
-  it{ expect(_(0).is_0?).to be_true }
-  it{ expect(1.is_1?).to be_true }
-  it{ expect(_(1).is_1?).to be_true }
-  it{ expect(-1.is_minus1?).to be_true }
-  it{ expect(_(-1).is_minus1?).to be_true }
+  context '#is_n?' do
+    it{ expect(0.is_0?).to be_true }
+    it{ expect(_(0).is_0?).to be_true }
+    it{ expect(inverse(0, :+).is_0?).to be_true }
+    it{ expect(1.is_1?).to be_true }
+    it{ expect(_(1).is_1?).to be_true }
+    it{ expect(inverse(1, :*).is_1?).to be_true }
+    it{ expect(-1.is_minus1?).to be_true }
+    it{ expect(_(-1).is_minus1?).to be_true }
+  end
 
-  it{ expect(0.is_multiple_of(:x).to_s).to eq('0') }
-  it{ expect(_(0).is_multiple_of(:y).to_s).to eq('0')}
+  context '#is_multiple_of' do
+    it{ expect(0.is_multiple_of(:x).to_s).to eq('0') }
+    it{ expect(_(0).is_multiple_of(:y).to_s).to eq('0')}
 
-  it{ expect(:x.is_multiple_of(:x).to_s).to eq('1') }
-  it{ expect(:x.is_multiple_of(:y)).to be_false }
+    it{ expect(:x.is_multiple_of(:x).to_s).to eq('1') }
+    it{ expect(:x.is_multiple_of(:y)).to be_false }
 
-  it{ expect((:x * :y).is_multiple_of(:x)).to eq(:y) }
-  it{ expect((:x * :y).is_multiple_of(:y)).to eq(:x) }
-  it{ expect((:x * :y).is_multiple_of(:z)).to be_false }
+    it{ expect((:x * :y).is_multiple_of(:x)).to eq(:y) }
+    it{ expect((:x * :y).is_multiple_of(:y)).to eq(:x) }
+    it{ expect((:x * :y).is_multiple_of(:z)).to be_false }
+  end
+
+  context '#combinable?' do
+    it{ expect(:x.combinable?(:x, :+)).to be_true }
+    it{ expect(:x.combinable?(:y, :+)).to be_false }
+    it{ expect(:x.combinable?(:x, :*)).to be_true }
+    it{ expect(:x.combinable?(:y, :*)).to be_false }
+    it{ expect(1.combinable?(2, :+)).to be_true }
+    it{ expect(1.combinable?(2, :*)).to be_true }
+  end
 
   let(:addition)      { (:x + :y) }
   let(:subtraction)   { (:x - :y) }
@@ -25,8 +40,11 @@ describe Helper do
   let(:exponentiation){ (:x ^ :y) }
 
   it{ expect(addition.addition?).to be_true }
-  it{ expect(subtraction.subtraction?).to be_true }
   it{ expect(multiplication.multiplication?).to be_true }
-  it{ expect(division.division?).to be_true }
   it{ expect(exponentiation.exponentiation?).to be_true }
+
+  it{ expect(inverse(:x, :+).inverse?(:x, :+)).to be_true }
+  it{ expect(:x.inverse?(inverse(:x, :+), :+)).to be_true }
+  it{ expect(inverse(:x, :*).inverse?(:x, :*)).to be_true }
+  it{ expect(:x.inverse?(inverse(:x, :*), :*)).to be_true }
 end

metadata

@@ -1,62 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: dydx
 version: !ruby/object:Gem::Version
-  version: 0.0.4
-  prerelease: 
+  version: 0.0.5
 platform: ruby
 authors:
 - gogotanaka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-12 00:00:00.000000000 Z
+date: 2014-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: It is possible to use the differential using the Symbol and Fixnum by
@@ -67,9 +60,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -78,14 +71,17 @@ files:
 - lib/dydx.rb
 - lib/dydx/algebra.rb
 - lib/dydx/algebra/formula.rb
+- lib/dydx/algebra/inverse.rb
 - lib/dydx/algebra/operator/common_parts.rb
 - lib/dydx/algebra/operator/formula.rb
 - lib/dydx/algebra/operator/general.rb
+- lib/dydx/algebra/operator/inverse.rb
 - lib/dydx/algebra/operator/num.rb
 - lib/dydx/algebra/operator/parts/base.rb
 - lib/dydx/algebra/operator/parts/formula.rb
 - lib/dydx/algebra/operator/parts/general.rb
 - lib/dydx/algebra/operator/parts/interface.rb
+- lib/dydx/algebra/operator/parts/inverse.rb
 - lib/dydx/algebra/operator/parts/num.rb
 - lib/dydx/algebra/operator/parts/symbol.rb
 - lib/dydx/algebra/operator/symbol.rb
@@ -106,6 +102,7 @@ files:
 - spec/lib/algebra/formula_spec.rb
 - spec/lib/algebra/operator/parts/base_spec.rb
 - spec/lib/algebra/operator/parts/formula_spec.rb
+- spec/lib/algebra/operator/parts/inverse_spec.rb
 - spec/lib/algebra/set/cos_spec.rb
 - spec/lib/algebra/set/e_spec.rb
 - spec/lib/algebra/set/fixnum_spec.rb
@@ -120,39 +117,33 @@ files:
 homepage: https://github.com/gogotanaka
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -708242121294730939
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -708242121294730939
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: We can enjoy the derivative.
 test_files:
 - spec/dydx_spec.rb
 - spec/lib/algebra/formula_spec.rb
 - spec/lib/algebra/operator/parts/base_spec.rb
 - spec/lib/algebra/operator/parts/formula_spec.rb
+- spec/lib/algebra/operator/parts/inverse_spec.rb
 - spec/lib/algebra/set/cos_spec.rb
 - spec/lib/algebra/set/e_spec.rb
 - spec/lib/algebra/set/fixnum_spec.rb