dydx 0.1.31 → 0.1.314

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6e4de7f815619a3ce01c34bc76a405749bd71f3b
-  data.tar.gz: 957aef1d10863b8fbacf8d142c5a8fd71d9c77e5
+  metadata.gz: c3575108c38dd6f4c3e191dcada2dfcc03e11b10
+  data.tar.gz: 37dbeb379531178c52253e213f6b79b930b0d9b7
 SHA512:
-  metadata.gz: 5236b464cc82383856640addf8bf5c0f725e68648282278195ac839050df72b35e65e444c15dbbd657b20a05dcb0fdf9df8046d123e735198dee306f764f8b07
-  data.tar.gz: a26cc47a1cb5be11eecb54c7358122dcd9d556644bda14a3a01e222db53779320736a9557036e9af9d967abfb37714f7019e559495bbb49e024f82bad9d5d20a
+  metadata.gz: 047b709dd5da3ec9b0058c86ced1755fbee7928279794c1f4d366c9f3e50c27a948e6feba092425073a3a3dc6781dfdacd4d5724aa947a41393ef6ae4e511c2f
+  data.tar.gz: 846c7e77de2aad86f4e65a8b7e6cac39f88c9427b00c39fe7297efc6aa2d34f260450233c09ecca108200e2f8eb1cec492f7d0af48815bf24d1e85c0f916b6f4

data/README.md

@@ -19,29 +19,31 @@ require 'dydx'
 include Dydx
 
 # Define the function. syntax is not good enough...
-f(x) <= x ^ 2
+f(x, y) <= x + x*y + y
 
-f(3)
-=> 9
+# simplify
+f(x, y) == x * (1 + y) + y
+=> true
 
-f(x).to_s
-=> "( x ^ 2 )"
+#part substitution
+f(a, 2) == 3*a + 2
+=> true
 
-f(x) == eval(f(x).to_s)
+f(1, a + b) == 1 + 2 * ( a + b )
 => true
 
+
 # Differentiate
-g(x) <= d/dx(f(x))
+d/dx(f(x, y)) == 1 + y
+=> true
 
-g(3)
-=> 6
+g(x) <= sin(x)
 
-g(x).to_s
-=> '2 * x'
+d/dx(g(x)) == cos(x)
 
 # Integrate
-S(f(x), dx)[0, 1]
-=> 0.3333333333333334
+S(g(x), dx)[0, pi/2]
+=> 1.0
 ```
 
 
@@ -52,18 +54,14 @@ f(z) <= log(z)
 S(f(z), dz)[0,1]
 => -Infinity
 
-( d/dx(log(x)) ).to_s
-=> "( 1 / x )"
-
-( d/dx(cos(x)) ).to_s
-=> "( - sin( x ) )"
+d/dx(log(x)) == 1 / x
+=> true
 
-( d/dx(e ^ x) ).to_s
-=> "( e ^ x )"
+d/dx(cos(x)) == -cos(x)
+=> true
 
-f(x) <= sin(x)
-S(f(x), dx)[0, Math::PI/2]
-=> 1.0
+d/dx(e ^ x) == e ^ x
+=> true
 
 # standard normal distribution;
 f(x) <= (1.0 / ( ( 2.0 * pi ) ^ 0.5 ) ) * ( e ^ (- (x ^ 2) / 2) )
@@ -71,38 +69,6 @@ S(f(x), dx)[-oo, oo]
 => 1.0
 ```
 
-#### it's like a magic...
-
-```ruby:
-f(x) <= x ^ 2
-
-f(a + b).to_s
-=> "( ( a + b ) ^ 2 )"
-
-#↓it's like a magic!!!
-g(a, b) <= f(a + b)
-
-g(a, b).to_s
-=> "( ( a + b ) ^ 2 )"
-
-g(2, 2)
-=> 16
-
-( d/da(g(a, b)) ).to_s
-=> "( 2 * ( a + b ) )"
-
-# simplify
-((x * y) + (z * x)).to_s
-=> "( x * ( y + z ) )"
-
-((x ^ y) / (x ^ z)).to_s
-=> "( x ^ ( y - z ) )"
-
-(x + x).to_s
-=> "( 2 * x )"
-```
-
-
 ## Documents
 I'm going to write now...cominng soon....
 
@@ -111,14 +77,11 @@ I'm going to write now...cominng soon....
 ```
 Dydx
   |- Algebra
-  |      |- Set
-  |      |   |- Num
-  |      |   |- ....
-  |      |
   |      |- Operator
   |      |   |- Interface
   |      |   |- ....
   |      |
+  |      |- Set
   |      |- Formula
   |      |- inverse
   |

data/lib/dydx.rb

@@ -6,7 +6,7 @@ require 'dydx/integrand'
 
 module Dydx
   include Algebra
-  %w(f g h).each do |functioner|
+  %w(f g h int_f).each do |functioner|
     define_method(functioner) do |*vars|
       function = eval("$#{functioner}")
       return eval("$#{functioner} = Function.new(*vars)") unless function
@@ -15,9 +15,12 @@ module Dydx
       return function if function.vars == vars
       return function unless function.algebra
 
-      string = substitute(vars, function)
-      string = rename_for_calc(string) if all_vars_num?(vars)
-      eval(string)
+      subst_hash = Hash[*[function.vars, vars].transpose.flatten]
+      begin
+        function.algebra.subst(subst_hash).to_f
+      rescue ArgumentError
+        eval(function.algebra.subst(subst_hash).to_s)
+      end
     end
   end
 

data/lib/dydx/algebra.rb

@@ -1,77 +1,11 @@
 require 'dydx/algebra/set'
-require 'dydx/algebra/operator'
 require 'dydx/algebra/formula'
 require 'dydx/algebra/inverse'
 
 module Dydx
   module Algebra
     include Set
-    module Set
-      # TODO: Refactor
-      Fixnum.class_eval do
-        alias_method :addition, :+
-        alias_method :subtraction, :-
-        alias_method :multiplication, :*
-        alias_method :division, :/
-        alias_method :exponentiation, :**
-        ope_to_str = {
-          addition: :+,
-          subtraction: :-,
-          multiplication: :*,
-          division: :/,
-          exponentiation: :^
-        }
-        %w(+ - * / ^).each do |operator|
-          define_method(operator) do |g|
-            if g.is_a?(Symbol) ||
-              g.is_a?(Formula) ||
-              g.is_a?(Base)
 
-              Num.new(self).send(operator.to_sym, g)
-            else
-              send(ope_to_str.key(operator.to_sym), g)
-            end
-          end
-        end
-      end
-
-      Float.class_eval do
-        alias_method :addition, :+
-        alias_method :subtraction, :-
-        alias_method :multiplication, :*
-        alias_method :division, :/
-        alias_method :exponentiation, :**
-        ope_to_str = {
-          addition: :+,
-          subtraction: :-,
-          multiplication: :*,
-          division: :/,
-          exponentiation: :^
-        }
-        %w(+ - * / ^).each do |operator|
-          define_method(operator) do |g|
-            if g.is_a?(Symbol) ||
-              g.is_a?(Formula) ||
-              g.is_a?(Base)
-
-              Num.new(self).send(operator.to_sym, g)
-            else
-              send(ope_to_str.key(operator.to_sym), g)
-            end
-          end
-        end
-      end
-      Symbol.class_eval{ include Operator::General }
-      class Num;    include Operator::Num; end
-      class E;      include Operator::General; end
-      class Pi;     include Operator::General; end
-      class Log;    include Operator::General; end
-      class Log2;   include Operator::General; end
-      class Log10;  include Operator::General; end
-      class Sin;    include Operator::General; end
-      class Cos;    include Operator::General; end
-      class Tan;    include Operator::General; end
-    end
     class Formula;  include Operator::Formula; end
     class Inverse;  include Operator::Inverse; end
 

data/lib/dydx/algebra/formula.rb

@@ -40,6 +40,14 @@ module Dydx
         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
@@ -49,9 +57,14 @@ module Dydx
         (f.combinable?(x, operator) || g.combinable?(x, operator))
       end
 
-      # TODO: interchangeable
       def ==(x)
-        to_s == x.to_s
+        if to_s == x.to_s
+          true
+        else
+          result = commutate!.to_s == x.to_s
+          commutate!
+          result
+        end
       end
 
       def common_factors(formula)

data/lib/dydx/algebra/inverse.rb

@@ -15,6 +15,20 @@ module Dydx
         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
+        end
+      end
+
       def differentiate(sym=:x)
         case operator
         when :+

data/lib/dydx/algebra/set.rb

@@ -1,20 +1,253 @@
-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/log2'
-require 'dydx/algebra/set/log10'
-require 'dydx/algebra/set/sin'
-require 'dydx/algebra/set/cos'
-require 'dydx/algebra/set/tan'
+require 'dydx/algebra/operator/parts'
+require 'dydx/algebra/operator/inverse'
+require 'dydx/algebra/operator/formula'
+require 'dydx/algebra/operator/num'
+require 'dydx/algebra/operator/general'
 
 module Dydx
   module Algebra
     module Set
+      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.to_s} )"
+          when Cos   then "cos( #{x.to_s} )"
+          when Tan   then "tan( #{x.to_s} )"
+          when Log   then "log( #{x.to_s} )"
+          when Log10 then "log10( #{x.to_s} )"
+          when Log2  then "log2( #{x.to_s} )"
+          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 raise 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
+
+      class Num
+        include Base
+        include Operator::Num
+      end
+
+      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
+
+      # FIX: Numeric
+      Fixnum.class_eval 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, :**
+        ope_to_str = {
+          addition: :+,
+          subtraction: :-,
+          multiplication: :*,
+          division: :/,
+          exponentiation: :^
+        }
+        %w(+ - * / ^).each do |operator|
+          define_method(operator) do |g|
+            if g.is_a?(Symbol) ||
+              g.is_a?(Formula) ||
+              g.is_a?(Base)
+
+              Num.new(self).send(operator.to_sym, g)
+            else
+              send(ope_to_str.key(operator.to_sym), g)
+            end
+          end
+        end
+      end
+
+      Float.class_eval 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, :**
+        ope_to_str = {
+          addition: :+,
+          subtraction: :-,
+          multiplication: :*,
+          division: :/,
+          exponentiation: :^
+        }
+        %w(+ - * / ^).each do |operator|
+          define_method(operator) do |g|
+            if g.is_a?(Symbol) ||
+              g.is_a?(Formula) ||
+              g.is_a?(Base)
+
+              Num.new(self).send(operator.to_sym, g)
+            else
+              send(ope_to_str.key(operator.to_sym), g)
+            end
+          end
+        end
+      end
+
+      Rational.class_eval 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, :**
+        ope_to_str = {
+          addition: :+,
+          subtraction: :-,
+          multiplication: :*,
+          division: :/,
+          exponentiation: :^
+        }
+        %w(+ - * / ^).each do |operator|
+          define_method(operator) do |g|
+            if g.is_a?(Symbol) ||
+              g.is_a?(Formula) ||
+              g.is_a?(Base)
+
+              Num.new(self).send(operator.to_sym, g)
+            else
+              send(ope_to_str.key(operator.to_sym), g)
+            end
+          end
+        end
+      end
+
       def e0
         eval("$e0 ||= Num.new(0)")
       end
@@ -22,12 +255,9 @@ module Dydx
       def e1
         eval("$e1 ||= Num.new(1)")
       end
+
       def _(num)
-        if num >= 0
-          eval("$p#{num} ||= Num.new(num)")
-        else
-          eval("$n#{-1 * num} ||= Num.new(num)")
-        end
+        Num.new(num)
       end
 
       def pi
@@ -117,7 +347,11 @@ module Dydx
       end
 
       def tan(x)
-        Tan.new(x)
+        if x == 0
+          0
+        else
+          Tan.new(x)
+        end
       end
     end
   end