dydx 0.0.9 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d8ca3c4000aeec1a5bf45fd3c7ed3fbd406d6617
-  data.tar.gz: 5de895a80ebd9d7684f0ef0544709979709293fc
+  metadata.gz: 6de4b80471ef9ac33664da33ff3f4a17a4c02714
+  data.tar.gz: e367d55b3bd7f8a59c1f7a0168f5a37e4d4c4881
 SHA512:
-  metadata.gz: dc98862c3a69ffc14d6ace6ebe15dcf41d1ce7559e5ab52713c9f48394ebb1fb7b18fbb0ccbcaf06dab58eadd1c8bf31acb2fa15ccca07f3563375cd7936df1e
-  data.tar.gz: ff75009f67db271fe0b7e25ed08d8e15bd724b1544b86b668e79c5e5b2a4b623de758a94d390e95da0e7deac2e7a5328f2477306e2521b5fd322362483e80da9
+  metadata.gz: ff580a632c292dc3bed05f880fc641d2308d96237e5c268d6d8a2f2353c0c7c520dc5422e810a39d572bd8ef33374d75f34a1f4615a32d393754a5cd0e108995
+  data.tar.gz: 8fcfb84b585244622fa596cdb08c2e0419af96d8e5bc384be9a3793e24ace35ad13474edc57301bbb53f7fd5664e0fe8226fd17f59cf20e5368bb1f443c14b3d

data/README.md

@@ -1,50 +1,84 @@
 # Dydx
-It always happens you want to differentiate with ruby. right?
-
-Dydx will eliminate this. Like this
+It always happens you want to differentiate some formulas with ruby. right?.....
 
+After `inlcude Dydx` , ruby become like other language.
 
 ```
-( d/dx(:x ^ 2) ).to_s
+require 'dydx'
+include Dydx
+
+# There are three types of differential interface
+
+( d/dx(x^2) ).to_s
 => "( 2 * x )"
 
-# pretermit '#to_s'
+log(z).d(z).to_s
+=> "( 1 / z )"
 
-d/dx(e ^ :x)
+$y = e ^ x
+(dy/dx).to_s
 => "( e ^ x )"
 
-d/dz(log(:z))
-=> "( 1 / z )"
+```
 
-d/dx(:x^:n)
-=> "( n * ( x ^ ( n - 1 ) ) )"
+You may wonder why undefined `x` , `e` and `z` are handleable?
+
+`method_missing` solve this problem by converting undefine variable into internal class object.
+
+Like this.
+
+```
+ x + x
+=> #<Dydx::Algebra::Formula:0x007fb0a4039fb0 @f=#<Dydx::Algebra::Set::Num:0x007fb0a48169e0 @n=2>, @operator=:*, @g=:x>
+
+e
+=> #<Dydx::Algebra::Set::E:0x007fb0a383e9f0>
+
+log(sin(x))
+=> #<Dydx::Algebra::Set::Log:0x007fe7cd971528 @f=#<Dydx::Algebra::Set::Sin:0x007fe7cd971550 @x=:x>>
+```
+
+And this DSL has strong 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 )"
 ```
 
-you can do like ``` dy/dx ```, if you use global var.
+I show some differential calculus.
 
 ```
-$y = cos(:x)
+# pretermit '#to_s'
+
+d/dz(log(z))
+=> "( 1 / z )"
+
+d/dx(x^n)
+=> "( n * ( x ^ ( n - 1 ) ) )"
+
+$y = cos(x)
 dy/dx
 => "( - sin( x ) )"
 
-$x = :a * ( (:t ^ 2) / 2 )
+$x = a * ( (t ^ 2) / 2 )
 dx/dt
 => "( a * t )"
 
 d/dt(dx/dt)
 =>"a"
 
-```
-
-you can use method chaining.
-
-```
-((:x ^ 2) * :y).d(:x)
+((x ^ 2) * y).d(x)
 => "( ( 2 * x ) * y )"
 
-((:x ^ 2) * :y).d(:x).d(:y)
+((x ^ 2) * y).d(x).d(y)
 => "( 2 * x )"
+
 ```
 
 
@@ -70,8 +104,17 @@ Or install it yourself as:
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/dydx/fork )
+1. Fork it ( https://github.com/gogotanaka/dydx/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create a new Pull Request
+
+## Test
+
+run `bundle exec rake spec`
+
+```
+Finished in 0.11282 seconds
+231 examples, 0 failures
+```

data/lib/dydx.rb

@@ -1,28 +1,49 @@
 require 'dydx/helper'
 require 'dydx/algebra'
+require 'dydx/delta'
+require 'dydx/function'
+require 'dydx/integrand'
 
 module Dydx
   include Algebra
-  class Delta
-    attr_accessor :var, :function
-    def initialize(var, function)
-      @var      = var
-      @function = function
-    end
-
-    def /(delta)
-      if var
-        eval("$#{var}").differentiate(delta.var)
-      elsif delta.function
-        delta.function.differentiate(delta.var)
+  # TODO: Refactor
+  %w(f g h).each do |functioner|
+    define_method(functioner) do |*vars|
+      if function = eval("$#{functioner}")
+        raise ArgumentError, "invalid number of values (#{vars.count} for #{function.vars.count})" unless function.vars.count == vars.count
+        return function if function.vars == vars
+        if function.algebra
+          string = function.algebra.to_s
+                     .gsub('cos', 'Math.cos')
+                     .gsub('sin', 'Math.sin')
+                     .gsub('log', 'Math.log')
+                     .gsub('e', 'Math::E')
+                     .gsub('pi', 'Math::Pi')
+          function.vars.each_with_index do |var, i|
+            string.gsub!(var.to_s, vars[i].to_s)
+          end
+          eval(string)
+        else
+          function
+        end
+      else
+        eval("$#{functioner} = Function.new(*vars)")
       end
     end
   end
 
+  def S(function, delta)
+    Integrand.new(function, delta.var)
+  end
+
+  def d
+    Delta.new
+  end
+
   def method_missing(method, *args, &block)
     method_name = method.to_s
-    if method_name =~ /^d.?$/
-      Delta.new(method_name[1] ?  method_name[1].to_sym : nil, args.first)
+    if method_name =~ /^d.$/
+      Delta.new(method_name[1].to_sym, args.first)
     elsif method_name =~ /^[a-z]$/
       method_name.to_sym
     else

data/lib/dydx/algebra.rb

@@ -13,6 +13,7 @@ module Dydx
   module Algebra
     include Set
     module Set
+      # TODO: Refactor
       Symbol.class_eval{ include Operator::Symbol }
       Fixnum.class_eval do
         %w(+ - * / ^).each do |operator|
@@ -22,16 +23,29 @@ module Dydx
               g.is_a?(Base)
 
               Num.new(self).send(operator.to_sym, g)
-            elsif operator == '^' && g.is_a?(Fixnum)
-              result = 1
-              g.times{ result *= self }
-              result
+            elsif operator == '^' && g.is_a?(Fixnum) || g.is_a?(Float)
+              self ** g
+            elsif operator == '^' && g.is_a?(Num)
+              self ** g.n
             else
               (to_f.send(operator.to_sym, g)).to_i
             end
           end
         end
       end
+      Float.class_eval do
+        %w(^).each do |operator|
+          define_method(operator) do |g|
+            if g.is_a?(Fixnum) || g.is_a?(Float)
+              self ** g
+            elsif g.is_a?(Num)
+              self ** g.n
+            else
+              Num.new(self).send(operator.to_sym, g)
+            end
+          end
+        end
+      end
       class Num;    include Operator::Num; end
       class E;      include Operator::General; end
       class Pi;     include Operator::General; end
@@ -54,5 +68,9 @@ module Dydx
         Inverse.new(x, operator)
       end
     end
+
+    def -@
+      inverse(self, :+)
+    end
   end
 end

data/lib/dydx/algebra/formula.rb

@@ -2,7 +2,7 @@ module Dydx
   module Algebra
     class Formula
       include Helper
-      attr_accessor :f, :g, :operator
+      attr_accessor :f, :operator, :g
 
       def initialize(f, g, operator)
         @f, @g, @operator = f, g, operator
@@ -16,7 +16,9 @@ module Dydx
           (f.d(sym) * g) + (f * g.d(sym))
         when :^
           # TODO:
-          if f == sym
+          if g.is_num?
+            f.d(sym) * g * (f ^ (g - 1) )
+          elsif f == sym
             g * (f ^ (g - 1))
           elsif f == e
             g.d(sym) * self

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

@@ -27,7 +27,7 @@ module Dydx
                 e0
               elsif operator == :* && inverse?(:*, x)
                 e1
-              elsif [:+, :*].include?(operator) && x.send("#{to_str(operator)}?")
+              elsif [:+, :*].include?(operator) && x.formula?(operator)
                 if combinable?(x.f, operator)
                   send(operator, x.f).send(operator, x.g)
                 elsif combinable?(x.g, operator)
@@ -35,7 +35,7 @@ module Dydx
                 else
                   super(x)
                 end
-              elsif x.is_a?(Inverse) && x.operator == operator && x.x.send("#{to_str(operator)}?")
+              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)

data/lib/dydx/algebra/set.rb

@@ -1,6 +1,7 @@
 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'

data/lib/dydx/algebra/set/float.rb

@@ -0,0 +1,14 @@
+module Dydx
+  module Algebra
+    module Set
+      Float.class_eval do
+        include Helper
+
+        def differentiate(sym=:x)
+          e0
+        end
+        alias_method :d, :differentiate
+      end
+    end
+  end
+end

data/lib/dydx/delta.rb

@@ -0,0 +1,17 @@
+module Dydx
+  class Delta
+    attr_accessor :var, :function
+    def initialize(var=nil, function=nil)
+      @var      = var
+      @function = function
+    end
+
+    def /(delta)
+      if var
+        eval("$#{var}").differentiate(delta.var)
+      elsif delta.function
+        delta.function.differentiate(delta.var)
+      end
+    end
+  end
+end

data/lib/dydx/function.rb

@@ -0,0 +1,26 @@
+module Dydx
+  class Function
+    attr_accessor :algebra, :vars
+    def initialize(*vars)
+      @vars = vars
+    end
+
+    def <=(algebra)
+      @algebra = algebra
+      self
+    end
+
+    def differentiate(sym=:x)
+      @algebra.differentiate(sym)
+    end
+    alias_method :d, :differentiate
+
+    def to_s
+      algebra.to_s
+    end
+
+    def ==(function)
+      to_s == function.to_s
+    end
+  end
+end

data/lib/dydx/helper.rb

@@ -39,11 +39,11 @@ module Dydx
     end
 
     def is_num?
-      (is_a?(Num) || is_a?(Fixnum)) || (is_a?(Inverse) && x.is_num?)
+      (is_a?(Num) || is_a?(Fixnum) || is_a?(Float)) || (is_a?(Inverse) && x.is_num?)
     end
 
     def is_0?
-      self == 0 || (is_a?(Num) && n == 0)
+      [0, 0.0].include?(self) || (is_a?(Num) && n.is_0?)
     end
 
     def is_1?
@@ -96,21 +96,6 @@ module Dydx
       end
     end
 
-    def to_str(sym)
-      OP_SYM_STR.key(sym)
-    end
-
-    def str_to_sym(str)
-      OP_SYM_STR[str]
-    end
-
-    def to_str_inv(operator)
-      {
-        subtrahend: :+,
-        divisor:    :*
-      }.key(operator)
-    end
-
     def rest(f_or_g)
       ([:f, :g] - [f_or_g]).first
     end

data/lib/dydx/integrand.rb

@@ -0,0 +1,22 @@
+module Dydx
+  class Integrand
+    attr_accessor :function, :var
+    def initialize(function, var)
+      @function = function
+      @var = var
+    end
+
+    def [](a, b, n = 100)
+      f = function
+      a, b = [a, b].map(&:to_f)
+      raise ArgumentError, 'b should be greater than a' if a > b
+      h = (b - a) / n
+      sum = 0.0
+      xi = ->(i){ a + h * i }
+      n.to_i.times do |i|
+        sum += ( f(xi.(i)) + 4.0 * f(xi.(i) + h / 2.0 ) + f(xi.(i) + h) ) rescue binding.pry
+      end
+      ( h * sum ) / 6.0
+    end
+  end
+end

data/lib/dydx/version.rb

@@ -1,3 +1,3 @@
 module Dydx
-  VERSION = "0.0.9"
+  VERSION = "0.1.0"
 end

data/spec/dydx_spec.rb

@@ -30,17 +30,9 @@ describe Dydx do
   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
-
-  context 'ex5' do
-    $f = 2 * (e ^ (2 * z))
-    let(:d1){ df/dz }
-    let(:d2){ d/dz($f) }
+    $i = 2 * (e ^ (2 * :z))
+    let(:d1){ di/dz }
+    let(:d2){ d/dz($i) }
     it{ expect(d1.to_s).to eq('( 4 * ( e ^ ( 2 * z ) ) )') }
     it{ expect(d2.to_s).to eq('( 4 * ( e ^ ( 2 * z ) ) )') }
   end

data/spec/lib/delta_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Dydx:Delta do
+  it{ expect(d.class).to eq(Delta) }
+  it{ expect(dx.class).to eq(Delta) }
+  it{ expect(dx.var).to eq(:x) }
+  it{ expect(dx(y).class).to eq(Delta) }
+  it{ expect(dx(y).var).to eq(:x) }
+  it{ expect(dx(y).function).to eq(:y) }
+  it{ expect{dxy}.to raise_error(NameError) }
+end

data/spec/lib/function_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Dydx:Function do
+  # TODO: refactor
+  it{ expect(f(x, y)).to eq(f(x, y)) }
+  it{ expect(f(x, y)).to eq($f) }
+  it{ expect(f(x, y).algebra).to be_nil }
+  it{ expect(f(x, y).vars).to eq([:x, :y]) }
+  it{ expect{f(x, y, z)}.to raise_error(ArgumentError) }
+  it{ expect{f(x)}.to raise_error(ArgumentError) }
+  it{ expect(f(x, y) <= x * y ).to eq(f(x, y)) }
+  it{ expect(f(x, y)).to eq(f(x, y)) }
+  it{ expect(f(x, y)).to eq($f) }
+  it{ expect(f(x, y).algebra).to eq(x * y) }
+  it{ expect(f(x, y)).to eq(x * y) }
+  it{ expect(eval(f(x, y).to_s)).to eq(f(x, y)) }
+  it{ expect(f(x, y)).to eq(eval(f(x, y).to_s)) }
+  it{ expect(f(a, b)).to eq(a * b) }
+  it{ expect(f(2, 3)).to eq(6) }
+  it{ expect(f(a + b, c)).to eq((a + b) * c) }
+  it{ expect(d/dx(f(x, y))).to eq(y) }
+  it{ expect(d/dy(f(x, y))).to eq(x) }
+  it{ expect(d/dz(f(x, y))).to eq(0) }
+
+  it{ expect(g(a, b) <= f(a + b, b)).to eq(g(a, b)) }
+  it{ expect(g(a, b)).to eq($g) }
+  it{ expect(g(2, 3)).to eq(15) }
+
+  it{ expect(h(a, b, c) <= d/db(g(a, b))).to eq(h(a, b, c)) }
+  it{ expect(h(a, b, c) <= d/db(g(a, b))).to eq($h) }
+  it{ expect(h(a, b, c)).to eq(( ( 2 * b ) + a )) }
+  it{ expect(h(a, b, c).algebra).to eq(( ( 2 * b ) + a )) }
+end

data/spec/lib/integrand_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Dydx:Integrand do
+  it 'ex1' do
+    f(x, y) <= x * y
+    integrand = S(f(x, y), dx)
+    expect(integrand.function).to eq(f(x, y))
+    expect(integrand.var).to eq(:x)
+    expect{integrand[4, 3]}.to raise_error(ArgumentError)
+  end
+
+  it 'ex2' do
+    $f = nil
+    f(x) <= x * x
+    expect(S(f(x), dx)[0, 1]).to eq(0.3333333333333334)
+  end
+
+  it 'ex3' do
+    $f = nil
+    f(x) <= sin(x)
+    expect(S(f(x), dx)[0, Math::PI/2]).to eq(1.000000000021139)
+  end
+
+  it 'ex4' do
+    $f = nil
+    f(x) <= cos(x)
+    expect(S(f(x), dx)[0, Math::PI]).to eq(7.440786129085082e-17)
+  end
+
+  it 'ex5' do
+    $f = nil
+    f(x) <= log(x)
+    expect(S(f(x), dx)[0, 1]).to eq(- Float::INFINITY)
+  end
+
+  # TODO
+  it 'ex6' do
+    $f = nil
+    f(x) <= e ^ (- (x^2))
+    expect(S(f(x), dx)[-100, 100]).to eq(1.672428604536991)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dydx
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.1.0
 platform: ruby
 authors:
 - gogotanaka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-21 00:00:00.000000000 Z
+date: 2014-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -90,13 +90,17 @@ files:
 - lib/dydx/algebra/set/cos.rb
 - lib/dydx/algebra/set/e.rb
 - lib/dydx/algebra/set/fixnum.rb
+- lib/dydx/algebra/set/float.rb
 - lib/dydx/algebra/set/log.rb
 - lib/dydx/algebra/set/num.rb
 - lib/dydx/algebra/set/pi.rb
 - lib/dydx/algebra/set/sin.rb
 - lib/dydx/algebra/set/symbol.rb
 - lib/dydx/algebra/set/tan.rb
+- lib/dydx/delta.rb
+- lib/dydx/function.rb
 - lib/dydx/helper.rb
+- lib/dydx/integrand.rb
 - lib/dydx/version.rb
 - spec/dydx_spec.rb
 - spec/lib/algebra/formula_spec.rb
@@ -112,7 +116,10 @@ files:
 - spec/lib/algebra/set/sin_spec.rb
 - spec/lib/algebra/set/symbol_spec.rb
 - spec/lib/algebra/set/tan_spec.rb
+- spec/lib/delta_spec.rb
+- spec/lib/function_spec.rb
 - spec/lib/helper_spec.rb
+- spec/lib/integrand_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/gogotanaka
 licenses:
@@ -153,5 +160,8 @@ test_files:
 - spec/lib/algebra/set/sin_spec.rb
 - spec/lib/algebra/set/symbol_spec.rb
 - spec/lib/algebra/set/tan_spec.rb
+- spec/lib/delta_spec.rb
+- spec/lib/function_spec.rb
 - spec/lib/helper_spec.rb
+- spec/lib/integrand_spec.rb
 - spec/spec_helper.rb