dydx 0.1.4 → 0.1.25

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

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Dydx::Algebra::Set::Log do
+  it{ expect(log(1)).to eq(_(0)) }
+  it{ expect(log(e)).to eq(_(1)) }
+  it{ expect(log(e ^ :n)).to eq(:n) }
+
+  describe '#to_s' do
+  end
+  describe '#differentiate' do
+    it{ expect(log(:x).d(:x).to_s).to eq('( 1 / x )') }
+  end
+  describe 'Calculate' do
+  end
+end

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

@@ -0,0 +1,23 @@
+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') }
+  end
+
+  describe '#differentiate' do
+    it{ expect(_(1).d(:x).to_s).to eq(_(0).to_s) }
+  end
+
+  describe '#==' do
+    it{ expect(_(1) == _(1)).to be_true }
+  end
+
+  describe 'Calculate' do
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Dydx::Algebra::Set::Pi do
+  it{ expect(pi).to eq(pi) }
+
+  describe '#to_s' do
+    it{ expect(pi.to_s).to eq('pi') }
+  end
+
+  describe '#differentiate' do
+    it{ expect(pi.d(:x).to_s).to eq(_(0).to_s) }
+  end
+
+  describe 'Calculate' do
+    context 'With Fixnum' do
+      it{ expect(pi + 0).to eq(pi) }
+      it{ expect(pi - 0).to eq(pi) }
+      it{ expect((pi * 0).to_s).to eq('0') }
+      it{ expect(pi * 1).to eq(pi) }
+      it{ expect{(pi / 0).to_s}.to raise_error(ZeroDivisionError) }
+      it{ expect(pi / 1).to eq(pi) }
+      it{ expect((pi ^ 0).to_s).to eq('1') }
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Dydx::Algebra::Set::Sin do
+  it{ expect(sin(pi)).to eq(_(0)) }
+
+  describe '#to_s' do
+    it{ expect(sin(:x).to_s).to eq('sin( x )') }
+  end
+  describe '#differentiate' do
+    it{ expect(sin(:x).d.to_s).to eq('cos( x )') }
+  end
+  describe 'Calculate' do
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Symbol do
+  describe '#to_s' do
+    it{ expect(:x.to_s).to eq('x') }
+  end
+  describe '#differentiate' do
+    it{ expect(:x.d(:x).to_s).to eq('1') }
+  end
+  describe 'Calculate' do
+    context 'With Fixnum' do
+    it{ expect(:x + 0).to eq(:x) }
+    it{ expect(:x - 0).to eq(:x) }
+    it{ expect((:x * 0).to_s).to eq('0') }
+    it{ expect(:x * 1).to eq(:x) }
+    it{ expect{(:x / 0).to_s}.to raise_error(ZeroDivisionError) }
+    it{ expect(:x / 1).to eq(:x) }
+    it{ expect((:x ^ 0).to_s).to eq('1') }
+    it{ expect(:x ^ 1).to eq(:x) }
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Dydx::Algebra::Set::Tan do
+  describe '#to_s' do
+    it{ expect(tan(:x).to_s).to eq('tan( x )') }
+  end
+
+  describe '#differentiate' do
+  end
+
+  describe 'Calculate' do
+  end
+end

data/spec/lib/delta_spec.rb

@@ -1,35 +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) }
-
-  before { reset }
-
-  it 'ex1' do
-    $y = x ** n
-    expect(dy/dx).to eq( n * ( x ** ( n - 1 ) ) )
-    expect(d/dx($y)).to eq( n * ( x ** ( n - 1 ) ) )
-  end
-
-  it 'ex2' do
-    $y = x ** (x * 2)
-    expect(dy/dx).to eq(( 2 * x ) * ( x ** ( ( 2 * x ) - 1 ) ))
-    expect(d/dx($y)).to eq(( 2 * x ) * ( x ** ( ( 2 * x ) - 1 ) ))
-  end
-
-  it 'ex3' do
-    $y = (t ** 2) / 2
-    expect(dy/dt).to eq(t)
-  end
-
-  it 'ex4' do
-    $y = 2 * (e ** (2 * z))
-    expect(dy/dz).to eq(4 * ( e ** ( 2 * z ) ))
-  end
+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

@@ -1,65 +1,39 @@
 require 'spec_helper'
 
-describe Dydx::Function do
-  before { reset }
-
-  it 'ex1' do
-    expect(f(x, y)).to eq(f(x, y))
-    expect(f(x, y)).to eq($f)
-    expect(f(x, y).algebra).to be_nil
-    expect(f(x, y).vars).to eq([:x, :y])
-    expect { f(x, y, z) }.to raise_error(ArgumentError)
-    expect { f(x) }.to raise_error(ArgumentError)
-  end
-
-  it 'ex2' do
-    expect(f(x, y) <= x * y ).to eq(f(x, y))
-    expect(f(x, y)).to eq(f(x, y))
-    expect(f(x, y)).to eq($f)
-    expect(f(x, y).algebra).to eq(x * y)
-    expect(f(x, y)).to eq(x * y)
-    expect(f(x, y)).to eq(eval(f(x, y).to_s))
-    expect(f(a, b)).to eq(a * b)
-    expect(f(2, x)).to eq(2 * x)
-    expect(f(2, 3)).to eq(6)
-    expect(f(a + b, c)).to eq((a + b) * c)
-    expect(d/dx(f(x, y))).to eq(y)
-    expect(d/dy(f(x, y))).to eq(x)
-    expect(d/dz(f(x, y))).to eq(0)
-  end
-
-  it 'ex3' do
-    f(x, y) <= x * y
-    g(a, b) <= f(a + b, b)
-    expect(g(a, b)).to eq((a + b) * b)
-    expect(g(a, 3)).to eq(9 + 3 * a)
-    expect(g(2, 3)).to eq(15)
-  end
-
-  it 'ex4' do
-    f(a, b) <= (a + b) * b
-    h(a, b, c) <= d/db(f(a, b))
-    expect(h(a, b, c)).to eq(( a + ( 2 * b ) ))
-    expect(h(a, b, c).algebra).to eq(( a + ( 2 * b ) ))
-  end
-
-  it 'ex5' do
+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 )) }
+
+  it 'ex.4' do
+    $f = nil
     f(x) <= log(x)
-    expect(f(e)).to eq(1)
-    expect(f(0)).to eq(-oo)
-    expect(f(y)).to eq(log(y))
-
-    g(x) <= d/dx(f(x))
-    expect(g(1)).to eq(1)
-  end
-
-  it 'ex6' do
-    f(x) <= sin(x)
-    expect(f(pi)).to eq(0)
-    expect(f(pi / 2)).to eq(1)
-    expect(f(y)).to eq(sin(y))
-
-    g(x) <= d/dx(f(x))
-    expect(g(pi)).to eq(-1)
+    expect(f(a)).to eq(log(a))
   end
 end

data/spec/lib/helper_spec.rb

@@ -3,63 +3,65 @@ require 'spec_helper'
 describe Helper do
   include Helper
   context '#is_n?' do
-    it { expect(0.zero?).to be true }
-    it { expect(_(0).zero?).to be true }
-    it { expect(inverse(0, :+).zero?).to be true }
-    it { expect(1.one?).to be true }
-    it { expect(_(1).one?).to be true }
-    it { expect(inverse(1, :*).one?).to be true }
-    it { expect(-1.minus1?).to be true }
-    it { expect(_(-1).minus1?).to be true }
+    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
 
-  context '#multiple_of?' do
-    it { expect(0.multiple_of?(x)).to be(true) }
+  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(4.multiple_of?(_(2))).to be(true) }
-    it { expect(_(4).multiple_of?(2)).to be(true) }
-    it { expect(_(4).multiple_of?(_(2))).to be(true) }
+    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.multiple_of?(x)).to be(true) }
-    it { expect(x.multiple_of?(y)).to be(false) }
-
-    it { expect((x * y).multiple_of?(x)).to be(true) }
-    it { expect((x * y).multiple_of?(x)).to be(true) }
-    it { expect((x * y).multiple_of?(z)).to be(false) }
-  end
-
-  context '#like_term?' do
-    it { expect(x.like_term?(x)).to be true }
-    it { expect((2 * x).like_term?((3 * x))).to be true }
+    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?(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(0.combinable?(:x, :**)).to be true }
-    it { expect(1.combinable?(:y, :**)).to be true }
+    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(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 }
+    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
 
-  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 }
+  let(:addition)      { (:x + :y) }
+  let(:subtraction)   { (:x - :y) }
+  let(:multiplication){ (:x * :y) }
+  let(:division)      { (:x / :y) }
+  let(:exponentiation){ (:x ^ :y) }
+
+  it{ expect(addition.addition?).to be_true }
+  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

data/spec/lib/integrand_spec.rb

@@ -1,29 +1,31 @@
 require 'spec_helper'
 
-describe Dydx::Integrand do
-  before { reset }
+describe Dydx:Integrand do
+  before(:each) do
+    reset
+  end
 
   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)
+    expect{integrand[4, 3]}.to raise_error(ArgumentError)
   end
 
   it 'ex2' do
     f(x) <= x * x
-    expect(S(f(x), dx)[0, 1]).to eq(0.33333333)
+    expect(S(f(x), dx)[0, 1]).to eq(0.3333333333333334)
   end
 
   it 'ex3' do
     f(x) <= sin(x)
-    expect(S(f(x), dx)[0, pi / 2]).to eq(1.0)
+    expect(S(f(x), dx)[0, Math::PI/2]).to eq(1.000000000021139)
   end
 
   it 'ex4' do
     f(x) <= cos(x)
-    expect(S(f(x), dx)[0, pi]).to eq(0.0)
+    expect(S(f(x), dx)[0, Math::PI]).to eq(7.440786129085082e-17)
   end
 
   it 'ex5' do
@@ -32,20 +34,20 @@ describe Dydx::Integrand do
   end
 
   it 'ex6' do
-    f(x) <= e ** -x ** 2
+    f(x) <= e ^ (- (x ^ 2))
     expect(f(0)).to eq(1)
-    expect(f(1)).to eq(1.0 / Math::E)
+    expect(f(1)).to eq(1.0/Math::E)
     expect(f(1000)).to eq(0)
-    expect(S(f(x), dx)[-1000, 1000, 3000]).to eq(1.77239273)
+    expect(S(f(x), dx)[-1000, 1000, 3000]).to eq(1.7724538506374117)
   end
 
   it 'ex7' do
-    f(x) <= (1.0 / ( 2.0 * Math::PI ) ** 0.5) * e ** (- x ** 2 / 2)
-    expect(S(f(x), dx)[-1000, 1000]).to eq(1.0)
+    f(x) <= (1.0 / ( ( 2.0 * Math::PI ) ^ 0.5 ) ) * ( e ^ (- (x ^ 2) / 2) )
+    expect(S(f(x), dx)[-1000, 1000, 1000]).to eq(0.9952054164466917)
   end
 
   it 'ex8' do
-    f(x) <= (1.0 / ( 2.0 * Math::PI ) ** 0.5) * e ** (- x ** 2 / 2)
-    expect(S(f(x), dx)[-oo, oo]).to eq(1.0)
+    f(x) <= (1.0 / ( ( 2.0 * pi ) ^ 0.5 ) ) * ( e ^ (- (x ^ 2) / 2) )
+    expect(S(f(x), dx)[-oo, oo, 1000]).to eq(0.9952054164466917)
   end
 end