dydx 0.0.1

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

@@ -0,0 +1,16 @@
+module Dydx
+  module Algebra
+    module Operator
+      module Parts
+        module Interface
+          %w(+ - * / ^).each do |operator|
+            define_method(operator) do |x|
+              x = _(x) if x.is_a?(Fixnum)
+              super(x)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Dydx
+  module Algebra
+    module Operator
+      module Parts
+        module Num
+          def +(x)
+            if n == 0
+              x
+            elsif x.is_a?(Num)
+              _(n + x.n)
+            else
+              super(x)
+            end
+          end
+
+          def -(x)
+            if x.is_a?(Num)
+              _(n - 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)
+            else
+              super(x)
+            end
+          end
+
+          def /(x)
+            if (n == 0)
+              self
+            else
+              super(x)
+            end
+          end
+
+          def ^(x)
+            if (n == 0) || (n == 1)
+              self
+            else
+              super(x)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Dydx
+  module Algebra
+    module Operator
+      module Parts
+        module Symbol
+          def *(x)
+            if x.exponentiation? &&
+              self == x.f
+
+              self ^ (1 + x.g)
+            else
+              super(x)
+            end
+          end
+
+          def /(x)
+            if x.exponentiation? &&
+              self == x.f
+
+              self ^ (1 - x.g)
+            else
+              super(x)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dydx/algebra/operator/symbol.rb

@@ -0,0 +1,15 @@
+require 'dydx/algebra/operator/common_parts'
+require 'dydx/algebra/operator/parts/symbol'
+
+module Dydx
+  module Algebra
+    module Operator
+      module Symbol
+        include Parts::Base
+        include Parts::Symbol
+        include Parts::General
+        include Parts::Interface
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Dydx
+  module Algebra
+    module Set
+      class Base
+        include Helper
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Dydx
+  module Algebra
+    module Set
+      class Cos < Base
+        attr_accessor :x
+
+        def initialize(x)
+          @x = x
+        end
+
+        def to_s
+          "cos( #{x.to_s} )"
+        end
+
+        def d(sym=:x)
+          -1 * sin(x) * x.d(sym)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Dydx
+  module Algebra
+    module Set
+      class E < Base
+        def differentiate(sym=:x)
+          _(0)
+        end
+        alias_method :d, :differentiate
+
+        def to_s
+          'e'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Dydx
+  module Algebra
+    module Set
+      Fixnum.class_eval do
+        include Helper
+
+        %w(+ - * / ^).each do |operator|
+          define_method(operator) do |g|
+            if g.is_a?(Symbol) ||
+              g.is_a?(Formula) ||
+              g.is_a?(Base) ||
+              %w(/ ^).include?(operator)
+
+              _(self).send(operator.to_sym, g)
+            else
+              (to_f.send(operator.to_sym, g)).to_i
+            end
+          end
+        end
+
+        def differentiate(sym=:x)
+          _(0)
+        end
+        alias_method :d, :differentiate
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Dydx
+  module Algebra
+    module Set
+      class Log < Base
+        attr_accessor :f
+
+        def initialize(f)
+          @f = f
+        end
+
+        def differentiate(sym=:x)
+          f.d(sym) / (f)
+        end
+        alias_method :d, :differentiate
+
+        def to_s
+          "log( #{f.to_s} )"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Dydx
+  module Algebra
+    module Set
+      class Num < Base
+        attr_accessor :n
+
+        def initialize(n)
+          @n = n
+        end
+
+        def differentiate(sym=:x)
+          _(0)
+        end
+        alias_method :d, :differentiate
+
+        def to_s
+          @n.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Dydx
+  module Algebra
+    module Set
+      class Pi < Base
+        def differentiate(sym=:x)
+          _(0)
+        end
+        alias_method :d, :differentiate
+
+        def to_s
+          'pi'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Dydx
+  module Algebra
+    module Set
+      class Sin < Base
+        attr_accessor :x
+
+        def initialize(x)
+          @x = x
+        end
+
+        def to_s
+          "sin( #{x.to_s} )"
+        end
+
+        def d(sym=:x)
+          cos(x) * x.d(sym)
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,17 @@
+module Dydx
+  module Algebra
+    module Set
+      class Tan < Base
+        attr_accessor :x
+
+        def initialize(x)
+          @x = x
+        end
+
+        def to_s
+          "tan( #{x.to_s} )"
+        end
+      end
+    end
+  end
+end

data/lib/dydx/helper.rb

@@ -0,0 +1,38 @@
+module Dydx
+  module Helper
+    def is_0?
+      self == 0 || (is_a?(Num) && n == 0)
+    end
+
+    def is_1?
+      self == 1 || (is_a?(Num) && n == 1)
+    end
+
+    def is_minus1?
+      self == -1 || (is_a?(Num) && n == -1)
+    end
+
+    def is_multiple_of(x)
+      is_multiple = if is_0?
+        _(0)
+      elsif self == x
+        _(1)
+      elsif is_a?(Formula) &&
+        (f == x || g == x)
+        f == x ? g : f
+      else
+        false
+      end
+    end
+
+    {
+      addition:       :+,
+      subtraction:    :-,
+      multiplication: :*,
+      division:       :/,
+      exponentiation: :^
+    }.each do |operator_name, operator|
+      define_method("#{operator_name}?") { @operator == operator }
+    end
+  end
+end

data/lib/dydx/version.rb

@@ -0,0 +1,3 @@
+module Dydx
+  VERSION = "0.0.1"
+end

data/spec/dydx_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Dydx do
+  it 'has a version number' do
+    expect(Dydx::VERSION).not_to be nil
+  end
+end

data/spec/lib/algebra/formula_spec.rb

@@ -0,0 +1,68 @@
+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) }
+  describe 'Calculate' do
+    context 'With Fixnum' do
+      let(:formula) { (:x + :y) }
+      it{ expect((formula + 0).to_s).to eq(formula.to_s) }
+      it{ expect((formula - 0).to_s).to eq(formula.to_s) }
+      it{ expect((formula * 0).to_s).to eq('0') }
+      it{ expect((formula * 1).to_s).to eq(formula.to_s) }
+      it{ expect{(formula / 0).to_s}.to raise_error(ZeroDivisionError) }
+      it{ expect(formula / 1).to eq(formula) }
+      it{ expect((formula ^ 0).to_s).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 '#differentiate' do
+    it{ expect(addition.d(:x).to_s).to eq('1') }
+    it{ expect(addition.d(:y).to_s).to eq('1') }
+    it{ expect(addition.d(:z).to_s).to eq('0') }
+
+    it{ expect(subtraction.d(:x).to_s).to eq('1') }
+    it{ expect(subtraction.d(:y).to_s).to eq('-1') }
+    it{ expect(subtraction.d(:z).to_s).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_s).to eq('0') }
+
+    it{ expect(division.d(:x).to_s).to eq("( y ^ -1 )") }
+    it{ expect(division.d(:y).to_s).to eq('( ( - x ) / ( y ^ 2 ) )') }
+    it{ expect(division.d(:z).to_s).to eq('0') }
+
+    it{ expect(exponentiation.d(:x).to_s).to eq('( y * ( x ^ ( y - 1 ) ) )') }
+    it{ expect(exponentiation.d(:y).to_s).to eq('( ( x ^ y ) * log( x ) )') }
+    it{ expect(exponentiation.d(:z).to_s).to eq('0') }
+  end
+
+  context 'With Symbol' 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 'With Symbol' 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
+end