dydx 0.1.4 → 0.1.25

data/lib/dydx/version.rb

@@ -1,3 +1,3 @@
 module Dydx
-  VERSION = '0.1.4'
+  VERSION = "0.1.25"
 end

data/spec/dydx_spec.rb

@@ -5,16 +5,35 @@ describe Dydx do
     expect(Dydx::VERSION).not_to be nil
   end
 
-  it 'demo' do
-    f(x, y) <= x + x * y + y
-    expect(f(x, y)).to eq(x * (1 + y) + y)
-    expect(f(a, 2)).to eq(3 * a + 2)
-    expect(f(1, a + b)).to eq(1 + 2 * ( a + b ))
-    expect(f(1, 2)).to eq(5)
-    expect(d/dx(f(x, y))).to eq(1 + y)
+  context 'ex1' do
+    $a = (:x ^ :n)
+    let(:d1){ da/dx }
+    let(:d2){ d/dx($a) }
+    it{ expect(d1.to_s).to eq('( n * ( x ^ ( n - 1 ) ) )') }
+    it{ expect(d2.to_s).to eq('( n * ( x ^ ( n - 1 ) ) )') }
+  end
+
+  context 'ex2' do
+    $b = (:x ^ (:x * 2))
+    let(:d1){ db/dx }
+    let(:d2){ d/dx($b) }
+    it{ expect(d1.to_s).to eq('( ( x * 2 ) * ( x ^ ( ( x * 2 ) - 1 ) ) )') }
+    it{ expect(d2.to_s).to eq('( ( x * 2 ) * ( x ^ ( ( x * 2 ) - 1 ) ) )') }
+  end
+
+  context 'ex3' do
+    $c = (:t ^ 2) / 2
+    let(:d1){ dc/dt }
+    let(:d2){ d/dt($c) }
+    it{ expect(d1.to_s).to eq('t') }
+    it{ expect(d2.to_s).to eq('t') }
+  end
 
-    g(x) <= sin(x)
-    expect(d/dx(g(x))).to eq(cos(x))
-    expect(S(g(x), dx)[0, pi / 2]).to eq(1.0)
+  context 'ex4' do
+    $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
 end

data/spec/lib/algebra/formula_spec.rb

@@ -1,69 +1,63 @@
 require 'spec_helper'
 
 describe Dydx::Algebra::Formula do
-  let(:addition)       { (x + y) }
-  let(:subtraction)    { (x - y) }
-  let(:multiplication) { (x * y) }
-  let(:division)       { (x / y) }
-  let(:exponentiation) { (x ** y) }
+  let(:addition)      { (:x + :y) }
+  let(:subtraction)   { (:x - :y) }
+  let(:multiplication){ (:x * :y) }
+  let(:division)      { (:x / :y) }
+  let(:exponentiation){ (:x ^ :y) }
   describe 'Calculate' do
     context 'With Fixnum' do
       let(:formula) { (:x + :y) }
-      it { expect(formula + 0).to eq(formula) }
-      it { expect(formula - 0).to eq(formula) }
-      it { expect(formula * 0).to eq(0) }
-      it { expect(formula * 1).to eq(formula) }
-      it { expect { (formula / 0).to_s }.to raise_error(ZeroDivisionError) }
-      it { expect(formula / 1).to eq(formula) }
-      it { expect(formula ** 0).to eq(1) }
+      it{ expect(formula + 0).to eq(formula) }
+      it{ expect(formula - 0).to eq(formula) }
+      it{ expect(formula * 0).to eq(0) }
+      it{ expect(formula * 1).to eq(formula) }
+      it{ expect{(formula / 0).to_s}.to raise_error(ZeroDivisionError) }
+      it{ expect(formula / 1).to eq(formula) }
+      it{ expect(formula ^ 0).to eq(1) }
     end
   end
 
   describe '#to_s' do
-    it { expect(addition.to_s).to eq('( x + y )') }
-    it { expect(subtraction.to_s).to eq('( x - y )') }
-    it { expect(multiplication.to_s).to eq('( x * y )') }
-    it { expect(division.to_s).to eq('( x / y )') }
-    it { expect(exponentiation.to_s).to eq('( x ** y )') }
-    it { expect((addition * multiplication).to_s).to eq('( ( x + y ) * ( x * y ) )') }
-  end
-
-  describe '#subst' do
-    it { expect((x + y).subst(x: 3, y: 3)).to eq(6) }
-    it { expect((x + y).subst(x: 3)).to eq(3 + y) }
-    it { expect((x + y + pi).subst(x: 3, y: 3).to_f).to eq(Math::PI + 6) }
+    it{ expect(addition.to_s).to eq('( x + y )') }
+    it{ expect(subtraction.to_s).to eq('( x - y )') }
+    it{ expect(multiplication.to_s).to eq('( x * y )') }
+    it{ expect(division.to_s).to eq('( x / y )') }
+    it{ expect(exponentiation.to_s).to eq('( x ^ y )') }
+    it{ expect( (addition * multiplication).to_s ).to eq('( ( x + y ) * ( x * y ) )') }
   end
 
   describe '#differentiate' do
-    it { expect(addition.d(x)).to eq(1) }
-    it { expect(addition.d(y)).to eq(1) }
-    it { expect(addition.d(z)).to eq(0) }
+    it{ expect(addition.d(:x)).to eq(1) }
+    it{ expect(addition.d(:y)).to eq(1) }
+    it{ expect(addition.d(:z)).to eq(0) }
 
-    it { expect(subtraction.d(x)).to eq(1) }
-    it { expect(subtraction.d(y)).to eq(-1) }
-    it { expect(subtraction.d(z)).to eq(0) }
+    it{ expect(subtraction.d(:x)).to eq(1) }
+    it{ expect(subtraction.d(:y)).to eq('( - 1 )') }
+    it{ expect(subtraction.d(:z)).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 eq(0) }
+    it{ expect(multiplication.d(:x)).to eq(:y) }
+    it{ expect(multiplication.d(:y)).to eq(:x) }
+    it{ expect(multiplication.d(:z)).to eq(0) }
 
-    it { expect(division.d(x)).to eq(1 / y) }
-    it { expect(division.d(y)).to eq(- ( x / y ** 2 ) ) }
-    it { expect(division.d(z)).to eq(0) }
+    it{ expect(division.d(:x)).to eq(1/:y) }
+    it{ expect(division.d(:y)).to eq('( - ( x / ( y ^ 2 ) ) )') }
+    it{ expect(division.d(:z)).to eq(0) }
 
-    it { expect(exponentiation.d(x)).to eq(y * x ** ( y - 1 )) }
-    it { expect(exponentiation.d(y)).to eq(x ** y * log(x)) }
-    it { expect(exponentiation.d(z)).to eq(0) }
+    it{ expect(exponentiation.d(:x).to_s).to eq('( y * ( x ^ ( y - 1 ) ) )') }
+    it{ expect(exponentiation.d(:y)).to eq((:x ^ :y) * log(:x)) }
+    it{ expect(exponentiation.d(:z)).to eq(0) }
   end
 
   describe '#include?' do
-    it { expect(addition.include?(x)).to be true }
-    it { expect(addition.include?(z)).to be false }
+    it{ expect(addition.include?(:x)).to be_true }
+    it{ expect(addition.include?(:z)).to be_false }
   end
 
   describe '#openable?' do
-    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 }
+    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/algebra/operator/parts/base_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe Dydx::Algebra::Operator::Parts::Base do
-  it { expect((:x + :x).to_s).to eq('( 2 * x )') }
-  it { expect((:x - :x).to_s).to eq('0') }
-  it { expect((:x * :x).to_s).to eq('( x ** 2 )') }
-  it { expect((:x / :x).to_s).to eq('1') }
-end
+  it{ expect((:x + :x).to_s).to eq('( 2 * x )') }
+  it{ expect((:x - :x).to_s).to eq('0') }
+  it{ expect((:x * :x).to_s).to eq('( x ^ 2 )') }
+  it{ expect((:x / :x).to_s).to eq('1') }
+end

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

@@ -1,63 +1,56 @@
 require 'spec_helper'
 
 describe Dydx::Algebra::Operator::Parts::Formula do
-  it { expect(a * b + a * c).to eq('( a * ( b + c ) )') }
-  it { expect(a * b + c * a).to eq('( a * ( b + c ) )') }
-  it { expect(b * a + c * a).to eq('( a * ( b + c ) )') }
-  it { expect(b * a + a * c).to eq('( a * ( b + c ) )') }
-  it { expect(a * b - a * c).to eq('( a * ( b - c ) )') }
-  it { expect(a * b - c * a).to eq('( a * ( b - c ) )') }
-  it { expect(b * a - c * a).to eq('( a * ( b - c ) )') }
-  it { expect(b * a - a * c).to eq('( a * ( b - c ) )') }
-
-  it { expect(a ** b * a ** c).to eq('( a ** ( b + c ) )') }
-  it { expect(a ** b * c ** a).to eq('( ( a ** b ) * ( c ** a ) )') }
-  it { expect(b ** a * c ** a).to eq('( ( b * c ) ** a )') }
-  it { expect(b ** a * a ** c).to eq('( ( b ** a ) * ( a ** c ) )') }
-  it { expect(a ** b / a ** c).to eq('( a ** ( b - c ) )') }
-  it { expect(a ** b / c ** a).to eq('( ( a ** b ) / ( c ** a ) )') }
-  it { expect(b ** a / c ** a).to eq('( ( b / c ) ** a )') }
-  it { expect(b ** a / a ** c).to eq('( ( b ** a ) / ( a ** c ) )') }
-
-  it { expect(((:x - 2) + 2).to_s).to eq('x') }
-  it { expect(((:x + 2) - 2).to_s).to eq('x') }
-  it { expect(((:x * 2) / 2).to_s).to eq('x') }
-  it { expect(((:x / 2) * 2).to_s).to eq('x') }
-
-  it { expect((2 + (:x - 2)).to_s).to eq('x') }
-  it { expect((2 - (:x + 2)).to_s).to eq('( - x )') }
-  it { expect((2 * (:x / 2)).to_s).to eq('x') }
-  it { expect((2 / (:x * 2)).to_s).to eq('( 1 / x )') }
-
-  it { expect((x + y) + y).to eq('( ( 2 * y ) + x )') }
-  it { expect((y + x) + y).to eq('( ( 2 * y ) + x )') }
-  it { expect((x - y) - y).to eq('( x - ( 2 * y ) )') }
-  it { expect((y - x) - y).to eq('( - x )') }
-  it { expect((y * x) * y).to eq('( ( y ** 2 ) * x )') }
-  it { expect((x * y) * y).to eq('( ( y ** 2 ) * x )') }
-  it { expect((x / y) / y).to eq('( x / ( y ** 2 ) )') }
-  it { expect((y / x) / y).to eq('( 1 / x )') }
-
-  it { expect(y + (x + y)).to eq('( ( 2 * y ) + x )') }
-  it { expect(y + (y + x)).to eq('( ( 2 * y ) + x )') }
-  it { expect(y - (x - y)).to eq('( ( 2 * y ) - x )') }
-  it { expect(y - (y - x)).to eq(x) }
-  it { expect(y * (y * x)).to eq('( ( y ** 2 ) * x )') }
-  it { expect(y * (x * y)).to eq('( ( y ** 2 ) * x )') }
-  it { expect(y - (x - y)).to eq('( ( 2 * y ) - x )') }
-  it { expect(y - (y - x)).to eq(x) }
-
-  it { expect((x + 3) * 2).to eq(x * 2 + 6) }
-  # it { expect((x - 3) * 2).to eq(x * 2 - 6) }
-  it { expect((x + 3) * 2).to eq(x * 2 + 6) }
-  it { expect((x + 3) * 2).to eq(x * 2 + 6) }
-
-  it { expect((x * 2) ** 2).to eq( 4 * x ** 2 ) }
-  it { expect((x / 2) ** 2).to eq( x ** 2 / 4 ) }
-
-  it { expect((3 * x + 4 * (x ** 2) + 4 * x).to_s).to eq('( ( 7 * x ) + ( 4 * ( x ** 2 ) ) )') }
+  it{ expect(((:a * :b) + (:a * :c)).to_s).to eq('( a * ( b + c ) )') }
+  it{ expect(((:a * :b) + (:c * :a)).to_s).to eq('( a * ( b + c ) )') }
+  it{ expect(((:b * :a) + (:c * :a)).to_s).to eq('( a * ( b + c ) )') }
+  it{ expect(((:b * :a) + (:a * :c)).to_s).to eq('( a * ( b + c ) )') }
+  it{ expect(((:a * :b) - (:a * :c)).to_s).to eq('( a * ( b - c ) )') }
+  it{ expect(((:a * :b) - (:c * :a)).to_s).to eq('( a * ( b - c ) )') }
+  it{ expect(((:b * :a) - (:c * :a)).to_s).to eq('( a * ( b - c ) )') }
+  it{ expect(((:b * :a) - (:a * :c)).to_s).to eq('( a * ( b - c ) )') }
+
+  it{ expect(((:a ^ :b) * (:a ^ :c)).to_s).to eq('( a ^ ( b + c ) )') }
+  it{ expect(((:a ^ :b) * (:c ^ :a)).to_s).to eq('( ( a ^ b ) * ( c ^ a ) )') }
+  it{ expect(((:b ^ :a) * (:c ^ :a)).to_s).to eq('( ( b * c ) ^ a )') }
+  it{ expect(((:b ^ :a) * (:a ^ :c)).to_s).to eq('( ( b ^ a ) * ( a ^ c ) )') }
+  it{ expect(((:a ^ :b) / (:a ^ :c)).to_s).to eq('( a ^ ( b - c ) )') }
+  it{ expect(((:a ^ :b) / (:c ^ :a)).to_s).to eq('( ( a ^ b ) / ( c ^ a ) )') }
+  it{ expect(((:b ^ :a) / (:c ^ :a)).to_s).to eq('( ( b / c ) ^ a )') }
+  it{ expect(((:b ^ :a) / (:a ^ :c)).to_s).to eq('( ( b ^ a ) / ( a ^ c ) )') }
+
+  it{ expect(((:x - 2) + 2).to_s).to eq('x') }
+  it{ expect(((:x + 2) - 2).to_s).to eq('x') }
+  it{ expect(((:x * 2) / 2).to_s).to eq('x') }
+  it{ expect(((:x / 2) * 2).to_s).to eq('x') }
+
+  it{ expect((2 + (:x - 2)).to_s).to eq('x') }
+  it{ expect((2 - (:x + 2)).to_s).to eq('( - x )') }
+  it{ expect((2 * (:x / 2)).to_s).to eq('x') }
+  it{ expect((2 / (:x * 2)).to_s).to eq('( 1 / x )') }
+
+  it{ expect(((:x + :y) + :y).to_s).to eq('( ( 2 * y ) + x )') }
+  it{ expect(((:y + :x) + :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(((:y * :x) * :y).to_s).to eq('( ( y ^ 2 ) * x )') }
+  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((:y + (:x + :y)).to_s).to eq('( ( 2 * y ) + x )') }
+  it{ expect((:y + (:y + :x)).to_s).to eq('( ( 2 * y ) + x )') }
+  it{ expect((:y - (:x - :y)).to_s).to eq('( ( 2 * y ) - x )') }
+  it{ expect((:y - (:y - :x)).to_s).to eq('x') }
+  it{ expect((:y * (:y * :x)).to_s).to eq('( ( y ^ 2 ) * x )') }
+  it{ expect((:y * (:x * :y)).to_s).to eq('( ( y ^ 2 ) * x )') }
+  it{ expect((:y - (:x - :y)).to_s).to eq('( ( 2 * y ) - x )') }
+  it{ expect((:y - (:y - :x)).to_s).to eq('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 )') }
 
   # TODO:
-  it { expect((2 ** (:x * 2)).to_s).to eq('( 2 ** ( 2 * x ) )') }
-  it { expect((2 ** (:x / 2)).to_s).to eq('( 2 ** ( x / 2 ) )') }
+  it{ expect((2 ^ (:x * 2)).to_s).to eq('( 2 ^ ( x * 2 ) )') }
+  it{ expect((2 ^ (:x / 2)).to_s).to eq('( 2 ^ ( x / 2 ) )') }
 end

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

@@ -1,14 +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_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(inverse(:x, :+)).to eq(inverse(:x, :+)) }
+  it{ expect(inverse(:x, :*)).to eq(inverse(:x, :*)) }
 
-  it { expect(x - x).to eq(0) }
-  it { expect(x / x).to eq(1) }
-  it { expect(inverse(x, :+) + x).to eq(0) }
-  it { expect(inverse(x, :*) * x).to eq(1) }
+  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/cos_spec.rb

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

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

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

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

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Fixnum do
+  describe '#to_s' do
+    it{ expect(1.to_s).to eq('1') }
+  end
+
+  describe '#differentiate' do
+    it{ expect(3.d(:x).to_s).to eq('0') }
+  end
+
+  describe 'Calculate' do
+    context 'With Formula' do
+      let(:formula) { (:x + :y) }
+      it{ expect((0 + formula).to_s).to eq(formula.to_s) }
+      it{ expect((0 - formula).to_s).to eq('( - ( x + y ) )') }
+      it{ expect((0 * formula).to_s).to eq('0') }
+      it{ expect((1 * formula).to_s).to eq(formula.to_s) }
+      it{ expect((0 / formula).to_s).to eq('0') }
+      it{ expect((1 / formula).to_s).to eq('( 1 / ( x + y ) )') }
+      it{ expect((0 ^ formula).to_s).to eq('0') }
+      it{ expect((1 ^ formula).to_s).to eq('1') }
+    end
+
+    context 'With Symbol' do
+      it{ expect(0 + :x).to eq(:x) }
+      it{ expect((0 - :x).to_s).to eq('( - x )') }
+      it{ expect((0 * :x).to_s).to eq('0') }
+      it{ expect(1 * :x).to eq(:x) }
+      it{ expect((0 / :x).to_s).to eq('0') }
+      it{ expect((1 / :x).to_s).to eq('( 1 / x )') }
+      it{ expect((0 ^ :x).to_s).to eq('0') }
+      it{ expect((1 ^ :x).to_s).to eq('1') }
+    end
+
+    context 'With Fixnum' do
+      it{ expect(0 + 3).to eq(3) }
+      it{ expect(3 + 0).to eq(3) }
+      it{ expect(2 + 3).to eq(5) }
+
+      it{ expect(0 - 3).to eq(-3) }
+      it{ expect(3 - 0).to eq(3) }
+      it{ expect(2 - 3).to eq(-1) }
+
+      it{ expect(0 * 3).to eq(0) }
+      it{ expect(3 * 0).to eq(0) }
+      it{ expect(1 * 3).to eq(3) }
+      it{ expect(3 * 1).to eq(3) }
+      it{ expect(3 * 2).to eq(6) }
+
+      it{ expect((0 / 3).to_s).to eq('0') }
+      it{ expect{(3 / 0).to_s}.to raise_error(ZeroDivisionError) }
+      it{ expect((3 / 1).to_s).to eq('3') }
+      # TODO:
+      it{ expect((2 / 3).to_s).to eq('0') }
+
+
+      it{ expect((0 ^ 3).to_s).to eq('0') }
+      it{ expect((3 ^ 0).to_s).to eq('1') }
+      it{ expect((1 ^ 3).to_s).to eq('1') }
+      it{ expect((3 ^ 1).to_s).to eq('3') }
+      it{ expect((3 ^ 2).to_s).to eq('9') }
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Float do
+  describe '#to_s' do
+    it{ expect(1.0.to_s).to eq('1.0') }
+  end
+
+  describe '#differentiate' do
+    it{ expect(3.0.d(:x).to_s).to eq('0') }
+  end
+
+  describe 'Calculate' do
+    context 'With Formula' do
+      let(:formula) { (:x + :y) }
+      it{ expect((0.0 + formula).to_s).to eq(formula.to_s) }
+      it{ expect((0.0 - formula).to_s).to eq('( - ( x + y ) )') }
+      it{ expect((0.0 * formula).to_s).to eq('0') }
+      it{ expect((1.0 * formula).to_s).to eq(formula.to_s) }
+      it{ expect((0.0 / formula).to_s).to eq('0') }
+      it{ expect((1.0 / formula).to_s).to eq('( 1 / ( x + y ) )') }
+      it{ expect((0.0 ^ formula).to_s).to eq('0') }
+      it{ expect((1.0 ^ formula).to_s).to eq('1') }
+    end
+
+    context 'With Symbol' do
+      it{ expect(0.0 + :x).to eq(:x) }
+      it{ expect((0.0 - :x).to_s).to eq('( - x )') }
+      it{ expect((0.0 * :x).to_s).to eq('0') }
+      it{ expect(1.0 * :x).to eq(:x) }
+      it{ expect((0.0 / :x).to_s).to eq('0') }
+      it{ expect((1.0 / :x).to_s).to eq('( 1 / x )') }
+      it{ expect((0.0 ^ :x).to_s).to eq('0') }
+      it{ expect((1.0 ^ :x).to_s).to eq('1') }
+    end
+
+    context 'With Float' do
+      it{ expect(0.0 + 3.0).to eq(3.0) }
+      it{ expect(3.0 + 0.0).to eq(3.0) }
+      it{ expect(2.0 + 3.0).to eq(5.0) }
+
+      it{ expect(0.0 - 3.0).to eq(-3.0) }
+      it{ expect(3.0 - 0.0).to eq(3.0) }
+      it{ expect(2.0 - 3.0).to eq(-1.0) }
+
+      it{ expect(0.0 * 3.0).to eq(0.0) }
+      it{ expect(3.0 * 0.0).to eq(0.0) }
+      it{ expect(1.0 * 3.0).to eq(3.0) }
+      it{ expect(3.0 * 1.0).to eq(3.0) }
+      it{ expect(3.0 * 2.0).to eq(6.0) }
+
+      it{ expect(0.0 / 3.0).to eq(0.0) }
+      it{ expect(3.0 / 0.0).to eq(oo) }
+      it{ expect(3.0 / 1.0).to eq(3.0) }
+      # TODO:
+      it{ expect(2.0 / 3.0).to eq(0.6666666666666666) }
+
+
+      it{ expect(0.0 ^ 3.0).to eq(0.0) }
+      it{ expect(3.0 ^ 0.0).to eq(1.0) }
+      it{ expect(1.0 ^ 3.0).to eq(1.0) }
+      it{ expect(3.0 ^ 1.0).to eq(3.0) }
+      it{ expect(3.0 ^ 2.0).to eq(9.0) }
+    end
+  end
+end