dydx 0.1.4 → 0.1.25

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,22 @@
+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 differentiate(sym=:x)
+          -1 * sin(x) * x.d(sym)
+        end
+        alias_method :d, :differentiate
+      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)
+          e0
+        end
+        alias_method :d, :differentiate
+
+        def to_s
+          'e'
+        end
+      end
+    end
+  end
+end

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

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

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/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,26 @@
+module Dydx
+  module Algebra
+    module Set
+      class Num < Base
+        attr_accessor :n
+
+        def initialize(n)
+          @n = n
+        end
+
+        def differentiate(sym=:x)
+          e0
+        end
+        alias_method :d, :differentiate
+
+        def to_s
+          @n.to_s
+        end
+
+        def ==(x)
+          to_s == x.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 ? e1 : e0
+        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/delta.rb

@@ -1,7 +1,7 @@
 module Dydx
   class Delta
     attr_accessor :var, :function
-    def initialize(var = nil, function = nil)
+    def initialize(var=nil, function=nil)
       @var      = var
       @function = function
     end

data/lib/dydx/function.rb

@@ -10,7 +10,7 @@ module Dydx
       self
     end
 
-    def differentiate(sym = :x)
+    def differentiate(sym=:x)
       @algebra.differentiate(sym)
     end
     alias_method :d, :differentiate

data/lib/dydx/helper.rb

@@ -1,9 +1,15 @@
 module Dydx
   module Helper
+    OP_SYM_STR = {
+      addition:       :+,
+      multiplication: :*,
+      exponentiation: :^
+    }
+
     SUPER_OPE_RELATION = {
       :+ => :*,
       :- => :/,
-      :* => :**,
+      :* => :^,
       :/ => :|
     }
 
@@ -12,75 +18,95 @@ module Dydx
       :- => :+,
       :* => :/,
       :/ => :*,
-      :** => :|,
-      :| => :**
+      :^ => :|,
+      :| => :^
     }
 
-    def num?
-      is_a?(Num) || is_a?(Numeric)
+    def super_ope(operator)
+      SUPER_OPE_RELATION[operator]
+    end
+
+    def sub_ope(operator)
+      SUPER_OPE_RELATION.invert[operator]
     end
 
-    def to_numeric
-      is_a?(Num) ? n : self
+    def inverse_ope(operator)
+      INVERSE_OPE_RELATION[operator]
     end
 
-    def zero?
-      [0, 0.0].include?(self) || (is_a?(Num) && n.zero?)
+    def inverse_super_ope(operator)
+      inverse_ope(super_ope(operator))
     end
 
-    def one?
-      [1, 1.0].include?(self) || (is_a?(Num) && n.one?)
+    def is_num?
+      (is_a?(Num) || is_a?(Fixnum) || is_a?(Float)) || (is_a?(Inverse) && x.is_num?)
     end
 
-    def minus1?
-      [-1, -1.0].include?(self) || (is_a?(Num) && n.minus1?)
+    def is_0?
+      [0, 0.0].include?(self) || (is_a?(Num) && n.is_0?)
+    end
+
+    def is_1?
+      [1, 1.0].include?(self) || (is_a?(Num) && n.is_1?)
+    end
+
+    def is_minus1?
+      [1, -1.0].include?(self)|| (is_a?(Num) && n.is_minus1?)
     end
 
     def distributive?(ope1, ope2)
-      [ope1.super, ope1.inv_super].include?(ope2)
+      [super_ope(ope1), inverse_super_ope(ope1)].include?(ope2)
     end
 
-    # TODO: Cyclomatic complexity for combinable? is too high. [17/6]
     def combinable?(x, operator)
       case operator
       when :+
-        (num? && x.num?) ||
-        (formula?(:*) && (f.num? || g.num?)) && x.num? ||
-        like_term?(x) ||
+        self == x ||
+        (is_num? && x.is_num?) ||
+        (multiplication? && (f == x || g == x)) ||
+        (x.multiplication? && (x.f == self || x.g == self)) ||
         inverse?(:+, x)
       when :*
         self == x ||
-        (num? && x.num?) ||
+        (is_num? && x.is_num?) ||
         inverse?(:*, x)
-      when :**
-        (num? && x.num?) || zero? || one?
+      when :^
+        (is_num? && x.is_num?) || is_0? || is_1?
       end
     end
 
-    # TODO: Cyclomatic complexity for combinable? is too high. [9/6]
-    def like_term?(x)
-      self == x                         ||
-      formula?(:*) && include?(x)       ||
-      x.formula?(:*) && x.include?(self)||
-      (formula?(:*) && formula?(:*) && !([f, g] & [x.f, x.g]).empty?)
+    def is_multiple_of(x)
+      if is_0?
+        e0
+      elsif self == x
+        e1
+      # elsif is_num? && x.is_num? && (self % x == 0)
+      #   _(n / x.n)
+      elsif multiplication? && (f == x || g == x)
+        f == x ? g : f
+      else
+        false
+      end
     end
 
-    # TODO: Cyclomatic complexity for combinable? is too high. [7/6]
-    def multiple_of?(x)
-      zero? ||
-      self == x ||
-      (num? && x.num? && self % x == 0) ||
-      (formula?(:*) && (f == x || g == x))
+    OP_SYM_STR.each do |operator_name, operator|
+      define_method("#{operator_name}?") do
+        is_a?(Formula) && (@operator == operator)
+        # is_a?(Inverse) && self.operator == operator
+      end
     end
 
     def rest(f_or_g)
       ([:f, :g] - [f_or_g]).first
     end
 
-    def distributable?(_operator)
+    def commutative?
     end
 
-    def inverse?(operator, x = nil)
+    def distributable?(operator)
+    end
+
+    def inverse?(operator, x=nil)
       if is_a?(Algebra::Inverse)
         self.operator == operator && (self.x == x || x.nil?)
       elsif x.is_a?(Algebra::Inverse)
@@ -98,26 +124,6 @@ module Dydx
       def commutative?
         [:+, :*].include?(self)
       end
-
-      def associative?
-        [:+, :*].include?(self)
-      end
-
-      def super
-        SUPER_OPE_RELATION[self] || self
-      end
-
-      def sub
-        SUPER_OPE_RELATION.invert[self] || self
-      end
-
-      def inv
-        INVERSE_OPE_RELATION[self] || self
-      end
-
-      def inv_super
-        self.super.inv
-      end
     end
 
     def ==(x)

data/lib/dydx/integrand.rb

@@ -1,38 +1,26 @@
 module Dydx
   class Integrand
     attr_accessor :function, :var
-
     def initialize(function, var)
       @function = function
       @var = var
     end
 
-    def [](a, b, n = 1000)
+    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
       # HOT FIX: should implement Infinity class
       a = - 1000 if a == - Float::INFINITY
       b = 1000 if b == Float::INFINITY
 
-      a, b = [a, b].map(&:to_f)
-      fail ArgumentError, 'b should be greater than a' if a > b
-      $temp_cal_f = function
-
-      n = [n, (b - a) * 2].max
-      n += 1 if n.to_i.odd?
       h = (b - a) / n
-      x = ->(i) { a + h * i }
-
-      odd_sum = (1..n - 1).to_a.select(&:odd?).inject(0) { |sum, i| sum += f(x.(i)) }
-      even_sum = (1..n - 1).to_a.select(&:even?).inject(0) { |sum, i| sum += f(x.(i)) }
-      round_8( (h / 3) * (f(a) + f(b) + 2 * even_sum + 4 * odd_sum) )
-    end
-
-    def f(vars)
-      temp_cal_f(vars)
-    end
-
-    def round_8(num)
-      return num if num.abs == Float::INFINITY
-      (num * 10 ** 8).round * 10.0 ** (-8)
+      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) )
+      end
+      ( h * sum ) / 6.0
     end
   end
 end