dydx 0.1.29 → 0.1.31

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6e4de7f815619a3ce01c34bc76a405749bd71f3b
+  data.tar.gz: 957aef1d10863b8fbacf8d142c5a8fd71d9c77e5
+SHA512:
+  metadata.gz: 5236b464cc82383856640addf8bf5c0f725e68648282278195ac839050df72b35e65e444c15dbbd657b20a05dcb0fdf9df8046d123e735198dee306f764f8b07
+  data.tar.gz: a26cc47a1cb5be11eecb54c7358122dcd9d556644bda14a3a01e222db53779320736a9557036e9af9d967abfb37714f7019e559495bbb49e024f82bad9d5d20a

data/.pryrc

@@ -0,0 +1,2 @@
+require 'dydx'
+include Dydx

data/Gemfile

@@ -2,4 +2,6 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in dydx.gemspec
 gem 'pry'
+gem 'pry-coolline'
+# gem 'pry-debugger'
 gemspec

data/README.md

@@ -1,4 +1,4 @@
-# Dydx is new math DSL in Ruby
+# Dydx is new MATH Language on Ruby.
 
 ### Since you report a bug, I will fix it within 24 hours.
 
@@ -8,6 +8,8 @@ we can handle math in the same sense sense of the math on paper.
 
 ex. limit, trigonometric functions and logarithmic.
 
+## We should enjoy MATH even using PC.
+(to say nothing of using pen.)
 
 After `inlcude Dydx` , ruby become like other language.
 
@@ -25,7 +27,7 @@ f(3)
 f(x).to_s
 => "( x ^ 2 )"
 
-f(x) == eval('f(x).to_s')
+f(x) == eval(f(x).to_s)
 => true
 
 # Differentiate
@@ -61,12 +63,12 @@ S(f(z), dz)[0,1]
 
 f(x) <= sin(x)
 S(f(x), dx)[0, Math::PI/2]
-=> 1.000000000021139
+=> 1.0
 
 # standard normal distribution;
 f(x) <= (1.0 / ( ( 2.0 * pi ) ^ 0.5 ) ) * ( e ^ (- (x ^ 2) / 2) )
 S(f(x), dx)[-oo, oo]
-=> 0.9952054164466917
+=> 1.0
 ```
 
 #### it's like a magic...
@@ -77,7 +79,7 @@ f(x) <= x ^ 2
 f(a + b).to_s
 => "( ( a + b ) ^ 2 )"
 
-#↓it"s magic!!!
+#↓it's like a magic!!!
 g(a, b) <= f(a + b)
 
 g(a, b).to_s
@@ -156,6 +158,6 @@ Or install it yourself as:
 run `bundle exec rake spec`
 
 ```
-Finished in 3.23 seconds
-309 examples, 0 failures
+Finished in 3.76 seconds
+325 examples, 0 failures
 ```

data/lib/dydx.rb

@@ -6,33 +6,18 @@ require 'dydx/integrand'
 
 module Dydx
   include Algebra
-  # TODO: Refactor
   %w(f g h).each do |functioner|
     define_method(functioner) do |*vars|
-      if function = eval("$#{functioner}")
-        raise ArgumentError, "invalid number of values (#{vars.count} for #{function.vars.count})" unless function.vars.count == vars.count
-        return function if function.vars == vars
-        if function.algebra
-          if vars.all?{|v| v.is_a?(Numeric)}
-            string = function.algebra.to_s
-                       .gsub('cos', 'Math.cos')
-                       .gsub('sin', 'Math.sin')
-                       .gsub('log', 'Math.log')
-                       .gsub('e', 'Math::E')
-                       .gsub('pi', 'Math::PI')
-          else
-            string = function.algebra.to_s
-          end
-          function.vars.each_with_index do |var, i|
-            string.gsub!(var.to_s, vars[i].to_s)
-          end
-          eval(string)
-        else
-          function
-        end
-      else
-        eval("$#{functioner} = Function.new(*vars)")
-      end
+      function = eval("$#{functioner}")
+      return eval("$#{functioner} = Function.new(*vars)") unless function
+
+      raise ArgumentError, "invalid number of values (#{vars.count} for #{function.vars.count})" unless function.vars.count == vars.count
+      return function if function.vars == vars
+      return function unless function.algebra
+
+      string = substitute(vars, function)
+      string = rename_for_calc(string) if all_vars_num?(vars)
+      eval(string)
     end
   end
 
@@ -58,4 +43,26 @@ module Dydx
       super
     end
   end
+
+  private
+
+  def substitute(vars, function)
+    string = function.algebra.to_s
+    function.vars.each_with_index { |var, i| string.gsub!(var.to_s, vars[i].to_s) }
+    string
+  end
+
+  def all_vars_num?(vars)
+    vars.all? { |v| v.is_a?(Numeric) }
+  end
+
+  def rename_for_calc(string)
+    # TODO: need more refactoring...
+    string.gsub!('cos', 'Math.cos')
+    string.gsub!('sin', 'Math.sin')
+    string.gsub!('log', 'Math.log')
+    string.gsub!(' e ', ' Math::E ')
+    string.gsub!('pi', 'Math::PI')
+    string
+  end
 end

data/lib/dydx/algebra.rb

@@ -1,20 +1,13 @@
+require 'dydx/algebra/set'
+require 'dydx/algebra/operator'
 require 'dydx/algebra/formula'
 require 'dydx/algebra/inverse'
 
-require 'dydx/algebra/set'
-
-require 'dydx/algebra/operator/inverse'
-require 'dydx/algebra/operator/formula'
-require 'dydx/algebra/operator/symbol'
-require 'dydx/algebra/operator/num'
-require 'dydx/algebra/operator/general'
-
 module Dydx
   module Algebra
     include Set
     module Set
       # TODO: Refactor
-      Symbol.class_eval{ include Operator::Symbol }
       Fixnum.class_eval do
         alias_method :addition, :+
         alias_method :subtraction, :-
@@ -68,10 +61,13 @@ module Dydx
           end
         end
       end
+      Symbol.class_eval{ include Operator::General }
       class Num;    include Operator::Num; end
       class E;      include Operator::General; end
       class Pi;     include Operator::General; end
       class Log;    include Operator::General; end
+      class Log2;   include Operator::General; end
+      class Log10;  include Operator::General; end
       class Sin;    include Operator::General; end
       class Cos;    include Operator::General; end
       class Tan;    include Operator::General; end

data/lib/dydx/algebra/operator.rb

@@ -0,0 +1,5 @@
+require 'dydx/algebra/operator/parts'
+require 'dydx/algebra/operator/inverse'
+require 'dydx/algebra/operator/formula'
+require 'dydx/algebra/operator/num'
+require 'dydx/algebra/operator/general'

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

@@ -1,6 +1,3 @@
-require 'dydx/algebra/operator/common_parts'
-require 'dydx/algebra/operator/parts/formula'
-
 module Dydx
   module Algebra
     module Operator

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

@@ -1,6 +1,3 @@
-require 'dydx/algebra/operator/common_parts'
-require 'dydx/algebra/operator/parts/general'
-
 module Dydx
   module Algebra
     module Operator

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

@@ -1,6 +1,3 @@
-require 'dydx/algebra/operator/common_parts'
-require 'dydx/algebra/operator/parts/inverse'
-
 module Dydx
   module Algebra
     module Operator

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

@@ -1,6 +1,3 @@
-require 'dydx/algebra/operator/common_parts'
-require 'dydx/algebra/operator/parts/num'
-
 module Dydx
   module Algebra
     module Operator

data/lib/dydx/algebra/operator/{common_parts.rb → parts.rb}

@@ -1,3 +1,6 @@
 require 'dydx/algebra/operator/parts/base'
 require 'dydx/algebra/operator/parts/general'
 require 'dydx/algebra/operator/parts/interface'
+require 'dydx/algebra/operator/parts/formula'
+require 'dydx/algebra/operator/parts/inverse'
+require 'dydx/algebra/operator/parts/num'

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

@@ -13,36 +13,36 @@ module Dydx
                 else
                   super(x)
                 end
-              elsif formula?(sub_ope(operator)) && openable?(operator, x)
-                f.send(operator, x).send(sub_ope(operator), g.send(operator, x))
-              elsif formula?(super_ope(operator)) && x.formula?(super_ope(operator))
+              elsif formula?(operator.sub) && openable?(operator, x)
+                f.send(operator, x).send(operator.sub, g.send(operator, x))
+              elsif formula?(operator.super) && x.formula?(operator.super)
                 w1, w2 = common_factors(x)
-                return super(x) unless (w1 && w2) && (super_ope(operator).commutative? || w1 == w2)
+                return super(x) unless (w1 && w2) && (operator.super.commutative? || w1 == w2)
 
                 case operator
                 when :+
-                  send(w1).send(super_ope(operator), send(rest(w1)).send(operator, x.send(rest(w2))))
+                  send(w1).send(operator.super, send(rest(w1)).send(operator, x.send(rest(w2))))
                 when :*
                   case w1
                   when :f
-                    send(w1).send(super_ope(operator), send(rest(w1)).send(sub_ope(operator), x.send(rest(w2))))
+                    send(w1).send(operator.super, send(rest(w1)).send(operator.sub, x.send(rest(w2))))
                   when :g
-                    send(w1).send(super_ope(operator), send(rest(w1)).send(operator, x.send(rest(w2)))).commutate!
+                    send(w1).send(operator.super, send(rest(w1)).send(operator, x.send(rest(w2)))).commutate!
                   end
                 end
-              elsif formula?(super_ope(operator)) && x.inverse?(operator) && x.x.formula?(super_ope(operator))
+              elsif formula?(operator.super) && x.inverse?(operator) && x.x.formula?(operator.super)
                 w1, w2 = common_factors(x.x)
-                return super(x) unless (w1 && w2) && (super_ope(operator).commutative? || w1 == w2)
+                return super(x) unless (w1 && w2) && (operator.super.commutative? || w1 == w2)
 
                 case operator
                 when :+
-                  send(w1).send(super_ope(operator), send(rest(w1)).send(inverse_ope(operator), x.x.send(rest(w2))))
+                  send(w1).send(operator.super, send(rest(w1)).send(inverse_ope(operator), x.x.send(rest(w2))))
                 when :*
                   case w1
                   when :f
-                    send(w1).send(super_ope(operator), send(rest(w1)).send(inverse_ope(sub_ope(operator)), x.x.send(rest(w2))))
+                    send(w1).send(operator.super, send(rest(w1)).send(inverse_ope(operator.sub), x.x.send(rest(w2))))
                   when :g
-                    send(w1).send(super_ope(operator), send(rest(w1)).send(inverse_ope(operator), x.x.send(rest(w2)))).commutate!
+                    send(w1).send(operator.super, send(rest(w1)).send(inverse_ope(operator), x.x.send(rest(w2)))).commutate!
                   end
                 end
               else
@@ -53,8 +53,8 @@ module Dydx
 
           %w(^).map(&:to_sym).each do |operator|
             define_method(operator) do |x|
-              if formula?(sub_ope(operator)) && openable?(operator, x)
-                f.send(operator, x).send(sub_ope(operator), g.send(operator, x))
+              if formula?(operator.sub) && openable?(operator, x)
+                f.send(operator, x).send(operator.sub, g.send(operator, x))
               else
                 super(x)
               end

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

@@ -35,6 +35,8 @@ module Dydx
                 else
                   super(x)
                 end
+              elsif [:+, :*].include?(operator) && x.formula?(operator.super) && self == x.f
+                send(operator.super, (1 + x.g))
               elsif x.is_a?(Inverse) && x.operator == operator && x.x.formula?(operator)
                 if combinable?(x.x.f, operator)
                   send(operator, inverse(x.x.f, operator)).send(operator, inverse(x.x.g, operator))

data/lib/dydx/algebra/set.rb

@@ -6,6 +6,8 @@ require 'dydx/algebra/set/symbol'
 require 'dydx/algebra/set/e'
 require 'dydx/algebra/set/pi'
 require 'dydx/algebra/set/log'
+require 'dydx/algebra/set/log2'
+require 'dydx/algebra/set/log10'
 require 'dydx/algebra/set/sin'
 require 'dydx/algebra/set/cos'
 require 'dydx/algebra/set/tan'
@@ -56,6 +58,44 @@ module Dydx
         end
       end
 
+      def log2(formula)
+        # TODO: refactor with log function.
+        if formula.multiplication?
+          f, g = formula.f, formula.g
+          log2(f) + log2(g)
+        elsif formula.exponentiation?
+          f, g = formula.f, formula.g
+          g * log2(f)
+        elsif formula.is_1?
+          e0
+        elsif formula.is_a?(Num)
+          (formula.n == 2) ? e1 : log2(formula.n)
+        elsif formula == 2
+          e1
+        else
+          Log2.new(formula)
+        end
+      end
+
+      def log10(formula)
+        # TODO: refactor with log function.
+        if formula.multiplication?
+          f, g = formula.f, formula.g
+          log10(f) + log10(g)
+        elsif formula.exponentiation?
+          f, g = formula.f, formula.g
+          g * log10(f)
+        elsif formula.is_1?
+          e0
+        elsif formula.is_a?(Num)
+          (formula.n == 10) ? e1 : log10(formula.n)
+        elsif formula == 10
+          e1
+        else
+          Log10.new(formula)
+        end
+      end
+
       def sin(x)
         multiplier = x.is_multiple_of(pi)
         if multiplier.is_a?(Num)

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

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

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

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

data/lib/dydx/helper.rb

@@ -22,20 +22,12 @@ module Dydx
       :| => :^
     }
 
-    def super_ope(operator)
-      SUPER_OPE_RELATION[operator]
-    end
-
-    def sub_ope(operator)
-      SUPER_OPE_RELATION.invert[operator]
-    end
-
     def inverse_ope(operator)
       INVERSE_OPE_RELATION[operator]
     end
 
     def inverse_super_ope(operator)
-      inverse_ope(super_ope(operator))
+      inverse_ope(operator.super)
     end
 
     def is_num?
@@ -55,7 +47,7 @@ module Dydx
     end
 
     def distributive?(ope1, ope2)
-      [super_ope(ope1), inverse_super_ope(ope1)].include?(ope2)
+      [ope1.super, ope1.inverse_super].include?(ope2)
     end
 
     def combinable?(x, operator)
@@ -132,6 +124,18 @@ module Dydx
       def commutative?
         [:+, :*].include?(self)
       end
+
+      def super
+        SUPER_OPE_RELATION[self] || self
+      end
+
+      def sub
+        SUPER_OPE_RELATION.invert[self] || self
+      end
+
+      def inverse_super
+        inverse_super_ope(self) || self
+      end
     end
 
     def ==(x)

data/lib/dydx/integrand.rb

@@ -6,21 +6,27 @@ module Dydx
       @var = var
     end
 
-    def [](a, b, n = 100)
-      f = function
-      a, b = [a, b].map(&:to_f)
+    def [](a, b, n = 1000)
       raise ArgumentError, 'b should be greater than a' if a > b
+      f = function
       # 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)
+      n = [n, (b - a) * 2].max
+      n += 1 if n.to_i.odd?
       h = (b - a) / n
-      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
+      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 round_8(num)
+      return num if num.abs == Float::INFINITY
+      (num * 10 ** 8).round * 10.0 ** (-8)
     end
   end
 end

data/lib/dydx/version.rb

@@ -1,3 +1,3 @@
 module Dydx
-  VERSION = "0.1.29"
+  VERSION = "0.1.31"
 end

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

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

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

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

data/spec/lib/integrand_spec.rb

@@ -15,17 +15,17 @@ describe Dydx:Integrand do
 
   it 'ex2' do
     f(x) <= x * x
-    expect(S(f(x), dx)[0, 1]).to eq(0.3333333333333334)
+    expect(S(f(x), dx)[0, 1]).to eq(0.33333333)
   end
 
   it 'ex3' do
     f(x) <= sin(x)
-    expect(S(f(x), dx)[0, Math::PI/2]).to eq(1.000000000021139)
+    expect(S(f(x), dx)[0, Math::PI/2]).to eq(1.0)
   end
 
   it 'ex4' do
     f(x) <= cos(x)
-    expect(S(f(x), dx)[0, Math::PI]).to eq(7.440786129085082e-17)
+    expect(S(f(x), dx)[0, Math::PI]).to eq(0.0)
   end
 
   it 'ex5' do
@@ -38,16 +38,16 @@ describe Dydx:Integrand do
     expect(f(0)).to eq(1)
     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.7724538506374117)
+    expect(S(f(x), dx)[-1000, 1000, 3000]).to eq(1.77239273)
   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, 1000]).to eq(0.9952054164466917)
+    expect(S(f(x), dx)[-1000, 1000]).to eq(1.0)
   end
 
   it 'ex8' do
-    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)
+    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)
   end
 end

metadata

@@ -1,62 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: dydx
 version: !ruby/object:Gem::Version
-  version: 0.1.29
-  prerelease: 
+  version: 0.1.31
 platform: ruby
 authors:
 - gogotanaka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-27 00:00:00.000000000 Z
+date: 2014-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Dydx is new math DSL in Ruby. The most important thing in this DSL is
@@ -67,9 +60,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".pryrc"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -79,11 +73,12 @@ files:
 - lib/dydx/algebra.rb
 - lib/dydx/algebra/formula.rb
 - lib/dydx/algebra/inverse.rb
-- lib/dydx/algebra/operator/common_parts.rb
+- lib/dydx/algebra/operator.rb
 - lib/dydx/algebra/operator/formula.rb
 - lib/dydx/algebra/operator/general.rb
 - lib/dydx/algebra/operator/inverse.rb
 - lib/dydx/algebra/operator/num.rb
+- lib/dydx/algebra/operator/parts.rb
 - lib/dydx/algebra/operator/parts/base.rb
 - lib/dydx/algebra/operator/parts/formula.rb
 - lib/dydx/algebra/operator/parts/general.rb
@@ -91,7 +86,6 @@ files:
 - lib/dydx/algebra/operator/parts/inverse.rb
 - lib/dydx/algebra/operator/parts/num.rb
 - lib/dydx/algebra/operator/parts/symbol.rb
-- lib/dydx/algebra/operator/symbol.rb
 - lib/dydx/algebra/set.rb
 - lib/dydx/algebra/set/base.rb
 - lib/dydx/algebra/set/cos.rb
@@ -99,6 +93,8 @@ files:
 - lib/dydx/algebra/set/fixnum.rb
 - lib/dydx/algebra/set/float.rb
 - lib/dydx/algebra/set/log.rb
+- lib/dydx/algebra/set/log10.rb
+- lib/dydx/algebra/set/log2.rb
 - lib/dydx/algebra/set/num.rb
 - lib/dydx/algebra/set/pi.rb
 - lib/dydx/algebra/set/sin.rb
@@ -118,6 +114,8 @@ files:
 - spec/lib/algebra/set/e_spec.rb
 - spec/lib/algebra/set/fixnum_spec.rb
 - spec/lib/algebra/set/float_spec.rb
+- spec/lib/algebra/set/log10_spec.rb
+- spec/lib/algebra/set/log2_spec.rb
 - spec/lib/algebra/set/log_spec.rb
 - spec/lib/algebra/set/num_spec.rb
 - spec/lib/algebra/set/pi_spec.rb
@@ -132,33 +130,26 @@ files:
 homepage: https://github.com/gogotanaka
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -4040478879646027093
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -4040478879646027093
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: We can enjoy the math.
 test_files:
 - spec/dydx_spec.rb
@@ -170,6 +161,8 @@ test_files:
 - spec/lib/algebra/set/e_spec.rb
 - spec/lib/algebra/set/fixnum_spec.rb
 - spec/lib/algebra/set/float_spec.rb
+- spec/lib/algebra/set/log10_spec.rb
+- spec/lib/algebra/set/log2_spec.rb
 - spec/lib/algebra/set/log_spec.rb
 - spec/lib/algebra/set/num_spec.rb
 - spec/lib/algebra/set/pi_spec.rb

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

@@ -1,15 +0,0 @@
-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