dydx 0.1.314 → 0.1.412

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,15 +1,9 @@
 module Dydx
   module Helper
-    OP_SYM_STR = {
-      addition:       :+,
-      multiplication: :*,
-      exponentiation: :^
-    }
-
     SUPER_OPE_RELATION = {
       :+ => :*,
       :- => :/,
-      :* => :^,
+      :* => :**,
       :/ => :|
     }
 
@@ -18,95 +12,75 @@ module Dydx
       :- => :+,
       :* => :/,
       :/ => :*,
-      :^ => :|,
-      :| => :^
+      :** => :|,
+      :| => :**
     }
 
-    def inverse_ope(operator)
-      INVERSE_OPE_RELATION[operator]
+    def num?
+      is_a?(Num) || is_a?(Numeric)
     end
 
-    def inverse_super_ope(operator)
-      inverse_ope(operator.super)
+    def to_numeric
+      is_a?(Num) ? n : self
     end
 
-    def is_num?
-      (is_a?(Num) || is_a?(Fixnum) || is_a?(Float)) || (is_a?(Inverse) && x.is_num?)
+    def zero?
+      [0, 0.0].include?(self) || (is_a?(Num) && n.zero?)
     end
 
-    def is_0?
-      [0, 0.0].include?(self) || (is_a?(Num) && n.is_0?)
+    def one?
+      [1, 1.0].include?(self) || (is_a?(Num) && n.one?)
     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?)
+    def minus1?
+      [-1, -1.0].include?(self) || (is_a?(Num) && n.minus1?)
     end
 
     def distributive?(ope1, ope2)
-      [ope1.super, ope1.inverse_super].include?(ope2)
+      [ope1.super, ope1.inv_super].include?(ope2)
     end
 
+    # TODO: Cyclomatic complexity for combinable? is too high. [17/6]
     def combinable?(x, operator)
       case operator
       when :+
-        (is_num? && x.is_num?) ||
-        (formula?(:*) && (f.is_num? || g.is_num?)) && x.is_num? ||
+        (num? && x.num?) ||
+        (formula?(:*) && (f.num? || g.num?)) && x.num? ||
         like_term?(x) ||
         inverse?(:+, x)
       when :*
         self == x ||
-        (is_num? && x.is_num?) ||
+        (num? && x.num?) ||
         inverse?(:*, x)
-      when :^
-        (is_num? && x.is_num?) || is_0? || is_1?
+      when :**
+        (num? && x.num?) || zero? || one?
       end
     end
 
+    # TODO: Cyclomatic complexity for combinable? is too high. [9/6]
     def like_term?(x)
-      boolean = if self == x
-      elsif formula?(:*) && include?(x)
-      elsif x.formula?(:*) && x.include?(self)
-      elsif ((formula?(:*) && formula?(:*)) && (([f, g] & [x.f, x.g]).any?{|x| x.is_a?(Symbol)}))
-      else
-        true
-      end
-
-     !boolean
-    end
-
-    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
+      self == x                         ||
+      formula?(:*) && include?(x)       ||
+      x.formula?(:*) && x.include?(self)||
+      (formula?(:*) && formula?(:*) && !([f, g] & [x.f, x.g]).empty?)
     end
 
-    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
+    # 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))
     end
 
     def rest(f_or_g)
       ([:f, :g] - [f_or_g]).first
     end
 
-    def distributable?(operator)
+    def distributable?(_operator)
     end
 
-    def inverse?(operator, x=nil)
+    def inverse?(operator, x = nil)
       if is_a?(Algebra::Inverse)
         self.operator == operator && (self.x == x || x.nil?)
       elsif x.is_a?(Algebra::Inverse)
@@ -125,6 +99,10 @@ module Dydx
         [:+, :*].include?(self)
       end
 
+      def associative?
+        [:+, :*].include?(self)
+      end
+
       def super
         SUPER_OPE_RELATION[self] || self
       end
@@ -133,18 +111,17 @@ module Dydx
         SUPER_OPE_RELATION.invert[self] || self
       end
 
-      def inverse_super
-        inverse_super_ope(self) || self
+      def inv
+        INVERSE_OPE_RELATION[self] || self
+      end
+
+      def inv_super
+        self.super.inv
       end
     end
 
     def ==(x)
       to_s == x.to_s
     end
-
-    # Refactor
-    def **(x)
-      self ^ (x)
-    end
   end
 end

data/lib/dydx/integrand.rb

@@ -1,6 +1,7 @@
 module Dydx
   class Integrand
     attr_accessor :function, :var
+
     def initialize(function, var)
       @function = function
       @var = var
@@ -12,21 +13,21 @@ module Dydx
       b = 1000 if b == Float::INFINITY
 
       a, b = [a, b].map(&:to_f)
-      raise ArgumentError, 'b should be greater than a' if a > b
-      $int_f = function
+      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 }
+      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))}
+      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)
-      int_f(vars)
+      temp_cal_f(vars)
     end
 
     def round_8(num)

data/lib/dydx/version.rb

@@ -1,3 +1,3 @@
 module Dydx
-  VERSION = "0.1.314"
+  VERSION = '0.1.412'
 end

data/spec/dydx_spec.rb

@@ -6,15 +6,15 @@ describe Dydx do
   end
 
   it 'demo' do
-    f(x, y) <= x + x*y + y
+    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(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)
 
     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)
+    expect(S(g(x), dx)[0, pi / 2]).to eq(1.0)
   end
 end

data/spec/lib/algebra/formula_spec.rb

@@ -1,69 +1,69 @@
 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 ) )') }
+    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((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) }
   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_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) }
+    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) }
   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,63 @@
 require 'spec_helper'
 
 describe Dydx::Algebra::Operator::Parts::Formula do
-  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 + 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_s).to eq('( 4 * ( x ^ 2 ) )') }
-  it{ expect(((:x / 2) ^ 2).to_s).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 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 ) ) )') }
 
   # 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 ** ( 2 * x ) )') }
+  it { expect((2 ** (:x / 2)).to_s).to eq('( 2 ** ( x / 2 ) )') }
 end