dydx 0.0.7 → 0.0.8

data/README.md

@@ -3,29 +3,52 @@ It always happens you want to differentiate with ruby. right?
 
 Dydx will eliminate this. Like this
 
+
 ```
-( d/dx(e ^ :x) ).to_s
+( d/dx(:x ^ 2) ).to_s
+=> "( 2 * x )"
+
+# pretermit '#to_s'
+
+d/dx(e ^ :x)
 => "( e ^ x )"
 
+d/dz(log(:z))
+=> "( 1 / z )"
+
+d/dx(:x^:n)
+=> "( n * ( x ^ ( n - 1 ) ) )"
+
+```
+
+you can do like ``` dy/dx ```, if you use global var.
+
+```
 $y = cos(:x)
-(dy/dx).to_s
+dy/dx
 => "( - sin( x ) )"
 
-# pretermit '.to_s'
+$x = :a * ( (:t ^ 2) / 2 )
+dx/dt
+=> "( a * t )"
 
-d/dx(log(:x))
-=> "( 1 / x )"
+d/dt(dx/dt)
+=>"a"
 
-d/dx(:x^:n)
-=> "( n * ( x ^ ( n - 1 ) ) )"
+```
 
+you can use method chaining.
 
-d/dx(:x^2)
-=> "( 2 * x )"
+```
+((:x ^ 2) * :y).d(:x)
+=> "( ( 2 * x ) * y )"
 
+((:x ^ 2) * :y).d(:x).d(:y)
+=> "( 2 * x )"
 ```
 
-(That's wonderful!!!!! But, I feel there is no meaning ... )
+
+(That's wonderful!!!!! ..............)
 
 ## Installation
 

data/lib/dydx/algebra/formula.rb

@@ -30,13 +30,13 @@ module Dydx
       def to_s
         if (multiplication? && (f.is_minus1? || g.is_minus1?)  )
           "( - #{g.to_s} )"
-        elsif multiplication? && g.divisor?
+        elsif multiplication? && g.inverse?(:*)
           "( #{f.to_s} / #{g.x.to_s} )"
-        elsif multiplication? && f.divisor?
+        elsif multiplication? && f.inverse?(:*)
           "( #{g.to_s} / #{f.x.to_s} )"
-        elsif addition? && g.subtrahend?
+        elsif addition? && g.inverse?(:+)
           "( #{f.to_s} - #{g.x.to_s} )"
-        elsif addition? && f.subtrahend?
+        elsif addition? && f.inverse?(:+)
           "( #{g.to_s} - #{f.x.to_s} )"
         else
           "( #{f.to_s} #{@operator} #{g.to_s} )"
@@ -47,8 +47,9 @@ module Dydx
         f == x || g == x
       end
 
-      def openable?(x)
-        x.is_num? && (f.is_num? || g.is_num?)
+      def openable?(operator, x)
+        distributive?(self.operator, operator) &&
+        (f.combinable?(x, operator) || g.combinable?(x, operator))
       end
 
       # TODO: interchangeable
@@ -75,4 +76,4 @@ module Dydx
       end
     end
   end
-end
+end

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

@@ -13,7 +13,7 @@ module Dydx
                 else
                   super(x)
                 end
-              elsif send("#{to_str(super_ope(operator))}?") && x.send("#{to_str(super_ope(operator))}?")
+              elsif formula?(super_ope(operator)) && x.formula?(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
@@ -26,7 +26,7 @@ module Dydx
                     send(w1).send(super_ope(operator), send(rest(w1)).send(operator, x.send(rest(w2)))).commutate!
                   end
                 end
-              elsif send("#{to_str(super_ope(operator))}?") && x.send("#{to_str_inv(operator)}?") && x.x.send("#{to_str(super_ope(operator))}?")
+              elsif formula?(super_ope(operator)) && x.inverse?(operator) && x.x.formula?(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
@@ -46,31 +46,12 @@ module Dydx
           end
 
           def ^(x)
-            if multiplication? && openable?(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
-
-          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

@@ -23,9 +23,9 @@ module Dydx
                 when :* then self ^ _(2)
                 when :^ then super(x)
                 end
-              elsif operator == :+ && inverse?(x, :+)
+              elsif operator == :+ && inverse?(:+, x)
                 e0
-              elsif operator == :* && inverse?(x, :*)
+              elsif operator == :* && inverse?(:*, x)
                 e1
               elsif [:+, :*].include?(operator) && x.send("#{to_str(operator)}?")
                 if combinable?(x.f, operator)
@@ -43,21 +43,13 @@ module Dydx
                 else
                   super(x)
                 end
-              elsif [:*].include?(operator) && x.subtrahend?
+              elsif [:*].include?(operator) && x.inverse?(:+)
                 inverse(::Algebra::Formula.new(self, x.x, operator.to_sym), :+)
               else
                 super(x)
               end
             end
           end
-
-          def to_str(operator)
-            {
-              addition:       :+,
-              multiplication: :*,
-              exponentiation: :^
-            }.key(operator)
-          end
         end
       end
     end

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

@@ -6,12 +6,10 @@ module Dydx
           %w(+ - * / ^).map(&:to_sym).each do |operator|
             define_method(operator) do |x|
               x = ::Set::Num.new(x) if x.is_a?(Fixnum)
-              case operator
-              when :-
-                self + inverse(x, :+)
-              when :/
-                raise ZeroDivisionError if x.is_0?
-                self * inverse(x, :*)
+              if operator == :/ && x.is_0?
+                raise ZeroDivisionError
+              elsif [:-, :/].include?(operator)
+                send(inverse_ope(operator), inverse(x, inverse_ope(operator)))
               else
                 super(x)
               end

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

@@ -3,30 +3,20 @@ module Dydx
     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, :*)
+          %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 == :+
+                x + self
+              elsif self.operator == :* && operator == :^
+                inverse(self.x ^ x, :*)
+              else
+                super(x)
+              end
             end
           end
         end

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

@@ -3,39 +3,29 @@ module Dydx
     module Operator
       module Parts
         module Num
-          def +(x)
-            if n == 0
-              x
-            elsif x.is_a?(Num)
-              _(n + x.n)
-            elsif x.subtrahend? && x.x.is_a?(Num)
-              _(n - x.x.n)
-            else
-              super(x)
-            end
-          end
-
-          def *(x)
-            if n == 0
-              self
-            elsif n == 1
-              x
-            elsif x.is_a?(Num)
-              _(n * x.n)
-            elsif x.divisor? && x.x.is_a?(Num)
-              _(n / x.x.n)
-            else
-              super(x)
-            end
-          end
-
-          def ^(x)
-            if (n == 0) || (n == 1)
-              self
-            elsif x.is_a?(Num)
-              _(n ^ x.n)
-            else
-              super(x)
+          %w(+ * ^).map(&:to_sym).each do |operator|
+            define_method(operator) do |x|
+              if is_0?
+                case operator
+                when :+ then x
+                when :* then e0
+                when :^ then e0
+                end
+              elsif is_1?
+                case operator
+                when :+ then super(x)
+                when :* then x
+                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
         end

data/lib/dydx/helper.rb

@@ -2,11 +2,46 @@ module Dydx
   module Helper
     OP_SYM_STR = {
       addition:       :+,
-      subtraction:    :-,
       multiplication: :*,
       exponentiation: :^
     }
 
+    SUPER_OPE_RELATION = {
+      :+ => :*,
+      :- => :/,
+      :* => :^,
+      :/ => :|
+    }
+
+    INVERSE_OPE_RELATION = {
+      :+ => :-,
+      :- => :+,
+      :* => :/,
+      :/ => :*,
+      :^ => :|,
+      :| => :^
+    }
+
+    def super_ope(operator)
+      SUPER_OPE_RELATION[operator]
+    end
+
+    def sub_ope(operator)
+      SUPER_OPE_RELATION.invert[operator]
+    end
+
+    def inverse_ope(operator)
+      INVERSE_OPE_RELATION[operator]
+    end
+
+    def inverse_super_ope(operator)
+      inverse_ope(super_ope(operator))
+    end
+
+    def is_num?
+      (is_a?(Num) || is_a?(Fixnum)) || (is_a?(Inverse) && x.is_num?)
+    end
+
     def is_0?
       self == 0 || (is_a?(Num) && n == 0)
     end
@@ -19,39 +54,35 @@ module Dydx
       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
+    def distributive?(ope1, ope2)
+      [super_ope(ope1), inverse_super_ope(ope1)].include?(ope2)
     end
 
     def combinable?(x, operator)
       case operator
+      when :+
+        self == x ||
+        (is_num? && x.is_num?) ||
+        (multiplication? && (f == x || g == x)) ||
+        (x.multiplication? && (x.f == self || x.g == self)) ||
+        inverse?(:+, x)
       when :*
         self == x ||
         (is_num? && x.is_num?) ||
-        inverse?(x, :*)
-      when :+
-        like_term?(x)
+        inverse?(:*, x)
+      when :^
+        (is_num? && x.is_num?) || is_0? || is_1?
       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)
+      if is_0?
+        e0
       elsif self == x
-        _(1)
-      elsif is_a?(Formula) &&
-        (f == x || g == x)
+        e1
+      # elsif is_num? && x.is_num? && (self % x == 0)
+      #   _(n / x.n)
+      elsif multiplication? && (f == x || g == x)
         f == x ? g : f
       else
         false
@@ -60,7 +91,7 @@ module Dydx
 
     OP_SYM_STR.each do |operator_name, operator|
       define_method("#{operator_name}?") do
-        (@operator == operator) && is_a?(Formula)
+        is_a?(Formula) && (@operator == operator)
         # is_a?(Inverse) && self.operator == operator
       end
     end
@@ -73,40 +104,26 @@ module Dydx
       OP_SYM_STR[str]
     end
 
-    def super_ope(operator)
-      case operator
-      when :+
-        :*
-      when :-
-        :/
-      when :*
-        :^
-      end
+    def to_str_inv(operator)
+      {
+        subtrahend: :+,
+        divisor:    :*
+      }.key(operator)
     end
 
-    def sub_ope(operator)
-      case operator
-      when :*
-        :+
-      end
+    def rest(f_or_g)
+      ([:f, :g] - [f_or_g]).first
     end
 
-    def inverse_ope(operator)
-      case operator
-      when :+
-        :-
-      when :*
-        :/
-      end
+    def commutative?
     end
 
-    def commutative?(operator)
-      [:+, :*].include?(operator)
+    def distributable?(operator)
     end
 
-    def inverse?(x, operator)
+    def inverse?(operator, x=nil)
       if is_a?(Algebra::Inverse)
-        self.operator == operator && self.x == x
+        self.operator == operator && (self.x == x || x.nil?)
       elsif x.is_a?(Algebra::Inverse)
         self == x.x
       else
@@ -114,12 +131,8 @@ module Dydx
       end
     end
 
-    def subtrahend?
-       is_a?(Inverse) && operator == :+
-    end
-
-    def divisor?
-       is_a?(Inverse) && operator == :*
+    def formula?(operator)
+      is_a?(Formula) && (@operator == operator)
     end
   end
 end

data/lib/dydx/version.rb

@@ -1,3 +1,3 @@
 module Dydx
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end

data/spec/lib/algebra/formula_spec.rb

@@ -56,7 +56,8 @@ describe Dydx::Algebra::Formula do
   end
 
   describe '#openable?' do
-    it{ expect((1 + :x).openable?(_(1))).to be_true }
-    it{ expect((1 + :x).openable?(:z)).to be_false }
+    it{ expect((:x + :y).openable?(:*, :x)).to be_true }
+    it{ expect((:x + :y).openable?(:*, :y)).to be_true }
+    it{ expect((:x + :y).openable?(:*, :z)).to be_false }
   end
 end

data/spec/lib/helper_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 
 describe Helper do
+  include Helper
   context '#is_n?' do
     it{ expect(0.is_0?).to be_true }
     it{ expect(_(0).is_0?).to be_true }
@@ -26,11 +27,27 @@ describe Helper do
 
   context '#combinable?' do
     it{ expect(:x.combinable?(:x, :+)).to be_true }
+    it{ expect(:x.combinable?(2 * :x, :+)).to be_true }
+    it{ expect((2 * :x).combinable?(:x, :+)).to be_true }
+    it{ expect((2 * :x).combinable?(2 * :x, :+)).to be_true }
     it{ expect(:x.combinable?(:y, :+)).to be_false }
+    it{ expect(1.combinable?(2, :+)).to be_true }
     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 }
+    it{ expect(0.combinable?(:x, :^)).to be_true }
+    it{ expect(1.combinable?(:y, :^)).to be_true }
+  end
+
+  context '#distributive?' do
+    it{ expect(distributive?(:+, :*)).to be_true }
+    it{ expect(distributive?(:+, :/)).to be_true }
+    it{ expect(distributive?(:-, :*)).to be_true }
+    it{ expect(distributive?(:-, :/)).to be_true }
+    it{ expect(distributive?(:*, :^)).to be_true }
+    it{ expect(distributive?(:/, :^)).to be_true }
+    it{ expect(distributive?(:*, :+)).to be_false }
+    it{ expect(distributive?(:^, :*)).to be_false }
   end
 
   let(:addition)      { (:x + :y) }
@@ -43,8 +60,8 @@ describe Helper do
   it{ expect(multiplication.multiplication?).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
+  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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dydx
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-19 00:00:00.000000000 Z
+date: 2014-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -136,7 +136,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4588855111168317577
+      hash: -728077447189178322
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -145,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4588855111168317577
+      hash: -728077447189178322
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23