dydx 0.1.314 → 0.1.412

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c3575108c38dd6f4c3e191dcada2dfcc03e11b10
-  data.tar.gz: 37dbeb379531178c52253e213f6b79b930b0d9b7
+  metadata.gz: 05be03d422e433fa724050ae6c77c6de2044005d
+  data.tar.gz: 5a8ef94f9d271d9383ac3308c0f77acec91c6864
 SHA512:
-  metadata.gz: 047b709dd5da3ec9b0058c86ced1755fbee7928279794c1f4d366c9f3e50c27a948e6feba092425073a3a3dc6781dfdacd4d5724aa947a41393ef6ae4e511c2f
-  data.tar.gz: 846c7e77de2aad86f4e65a8b7e6cac39f88c9427b00c39fe7297efc6aa2d34f260450233c09ecca108200e2f8eb1cec492f7d0af48815bf24d1e85c0f916b6f4
+  metadata.gz: 9c2d8881754f7ee43700223926c2a249d91c3431bcc49ce9886c8c2991e5c58694a83626d5d1947c97c822208159d487343d8a85e353448ad7843177446757a7
+  data.tar.gz: 4a89a20e3810e52c23c97d88dd915e2a54263374e3f1a9b8a52ca444f9f1e3b219e63d1367be693a3787bf4f10f6e69f86baf6e9bc97ab1d2f2c7c5b46590760

data/.rubocop.yml

@@ -0,0 +1,25 @@
+Eval:
+  Enabled: false
+
+LineLength:
+  Enabled: false
+
+# Configuration parameters: AllowedVariables.
+GlobalVars:
+  Enabled: false
+
+# Configuration parameters: EnforcedStyle, SupportedStyles.
+MethodName:
+  Enabled: false
+
+OpMethod:
+  Enabled: false
+
+Void:
+  Enabled: false
+
+SpaceInsideParens:
+  Enabled: false
+
+SpaceAroundOperators:
+  Enabled: false

data/.travis.yml

@@ -1,6 +1,8 @@
 language:  ruby
 rvm:
+  - 2.0.0
   - 2.1.1
+  - jruby-head
 script: rake spec
 notifications:
-  email:  qlli.illb@gmail.com
+  email:  mail@tanakakazuki.com

data/Gemfile

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

data/README.md

@@ -2,6 +2,8 @@
 
 ### Since you report a bug, I will fix it within 24 hours.
 
+[![Build Status](https://travis-ci.org/gogotanaka/dydx.svg?branch=master)](https://travis-ci.org/gogotanaka/dydx)
+
 The most important thing in this DSL is
 
 we can handle math in the same sense sense of the math on paper.
@@ -60,11 +62,11 @@ d/dx(log(x)) == 1 / x
 d/dx(cos(x)) == -cos(x)
 => true
 
-d/dx(e ^ x) == e ^ x
+d/dx(e ** x) == e ** x
 => true
 
 # standard normal distribution;
-f(x) <= (1.0 / ( ( 2.0 * pi ) ^ 0.5 ) ) * ( e ^ (- (x ^ 2) / 2) )
+f(x) <= (1.0 / ( 2.0 * pi ) ** 0.5) * e ** (- x ** 2 / 2)
 S(f(x), dx)[-oo, oo]
 => 1.0
 ```

data/Rakefile

@@ -1,13 +1,10 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 require 'bundler/setup'
 
-desc "run spec"
+desc 'run spec'
 
-#do `rake spec`
-RSpec::Core::RakeTask.new(:spec) do |t|
-  t.rspec_opts = ["-c", "-fs"]
-end
+# do `rake spec`
+RSpec::Core::RakeTask.new(:spec)
 
 task default: :spec
-

data/dydx.gemspec

@@ -4,22 +4,22 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'dydx/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "dydx"
+  spec.name          = 'dydx'
   spec.version       = Dydx::VERSION
-  spec.authors       = ["gogotanaka"]
-  spec.email         = ["qlli.illb@gmail.com"]
-  spec.homepage      = "https://github.com/gogotanaka"
-  spec.summary       = %q{We can enjoy the math.}
-  spec.description   = %q{Dydx is new math DSL in Ruby. The most important thing in this DSL is we can handle math in the same sense sense of the math on paper.}
+  spec.authors       = ['gogotanaka']
+  spec.email         = ['mail@tanakakazuki.com']
+  spec.homepage      = 'http://gogotanaka.me/'
+  spec.summary       = %q(We can enjoy the math.)
+  spec.description   = %q(Dydx is new math DSL in Ruby. The most important thing in this DSL is we can handle math in the same sense sense of the math on paper.)
 
-  spec.license       = "MIT"
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.6"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
 end

data/lib/dydx.rb

@@ -6,14 +6,13 @@ require 'dydx/integrand'
 
 module Dydx
   include Algebra
-  %w(f g h int_f).each do |functioner|
+  %w(f g h temp_cal_f).each do |functioner|
     define_method(functioner) do |*vars|
       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
+      fail ArgumentError, "invalid number of values (#{vars.count} for #{function.vars.count})" unless function.vars.count == vars.count
+      return function if function.vars == vars || !function.algebra
 
       subst_hash = Hash[*[function.vars, vars].transpose.flatten]
       begin
@@ -25,7 +24,12 @@ module Dydx
   end
 
   def S(function, delta)
-    Integrand.new(function, delta.var)
+    itgrl_var = delta.var
+    unless function.is_a?(Function)
+      eval "g(#{itgrl_var}) <= #{function}"
+      function = g(x)
+    end
+    Integrand.new(function, itgrl_var)
   end
 
   def d
@@ -36,6 +40,17 @@ module Dydx
     $f, $g, $h = nil, nil, nil
   end
 
+  def _(*args)
+    case args.count
+    when 1
+      num = args.first
+      Num.new(num)
+    when 3
+      ltr, op, rtr = args
+      ltr.send(op, rtr)
+    end
+  end
+
   def method_missing(method, *args, &block)
     method_name = method.to_s
     if method_name =~ /^d.$/
@@ -46,26 +61,4 @@ 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,6 +1,4 @@
 require 'dydx/algebra/set'
-require 'dydx/algebra/formula'
-require 'dydx/algebra/inverse'
 
 module Dydx
   module Algebra
@@ -9,11 +7,15 @@ module Dydx
     class Formula;  include Operator::Formula; end
     class Inverse;  include Operator::Inverse; end
 
+    # TODO: Cyclomatic complexity for inverse is too high. [7/6]
     def inverse(x, operator)
-      if operator == :+ && x.is_0?
-        e0
-      elsif operator == :* && x.is_1?
-        e1
+      if x.num?
+        x = x.to_numeric
+        if operator == :+
+          _(- x)
+        else
+          _(Rational(1, x))
+        end
       elsif x.is_a?(Inverse) && x.operator == operator
         x.x
       else

data/lib/dydx/algebra/formula.rb

@@ -2,23 +2,44 @@ module Dydx
   module Algebra
     class Formula
       include Helper
-      attr_accessor :f, :operator, :g
+      attr_accessor :operator, :terms
 
-      def initialize(f, g, operator)
-        g, f = f, g if g.is_num? && operator.commutative?
-        @f, @g, @operator = f, g, operator
+      def initialize(operator, *terms)
+        @operator, @terms = operator, terms
+        commutate! if (terms[1].num? && operator.commutative?)
       end
 
-      def differentiate(sym=:x)
+      def f
+        @terms[0]
+      end
+
+      def g
+        @terms[1]
+      end
+
+      def f=(x)
+        @terms[0] = x
+      end
+
+      def g=(x)
+        @terms[1] = x
+      end
+
+      def tms
+        terms
+      end
+
+      # TODO: Cylomatic complexity for differentiate is too high. [7/6]
+      def differentiate(sym = :x)
         case @operator
         when :+ then f.d(sym) + g.d(sym)
         when :* then (f.d(sym) * g) + (f * g.d(sym))
-        when :^
+        when :**
           # TODO:
-          if g.is_num?
-            f.d(sym) * g * (f ^ (g - 1) )
+          if g.num?
+            f.d(sym) * g * (f ** (g - 1))
           elsif f == sym
-            g * (f ^ (g - 1))
+            g * (f ** (g - 1))
           elsif f == e
             g.d(sym) * self
           else
@@ -29,14 +50,18 @@ module Dydx
       alias_method :d, :differentiate
 
       def to_s
-        if (formula?(:*) && (f.is_minus1? || g.is_minus1?)  )
-          "( - #{g.to_s} )"
+        if formula?(:*) && (f.minus1? || g.minus1?)
+          "( - #{g} )"
         elsif g.inverse?(operator)
-          "( #{f.to_s} #{inverse_ope(operator)} #{g.x.to_s} )"
+          "( #{f} #{operator.inv} #{g.x} )"
         elsif f.inverse?(operator)
-          "( #{g.to_s} #{inverse_ope(operator)} #{f.x.to_s} )"
+          "( #{g} #{operator.inv} #{f.x} )"
+        elsif formula?(:*) && !rationals.empty?
+          terms = [f, g]
+          terms.delete(rationals.first)
+          "( #{(terms.first * rationals.first.n.numerator)} / #{rationals.first.n.denominator} )"
         else
-          "( #{f.to_s} #{operator} #{g.to_s} )"
+          "( #{f} #{operator} #{g} )"
         end
       end
 
@@ -57,6 +82,10 @@ module Dydx
         (f.combinable?(x, operator) || g.combinable?(x, operator))
       end
 
+      def rationals
+        [f, g].select{ |term| term.num? && term.n.is_a?(Rational) }
+      end
+
       def ==(x)
         if to_s == x.to_s
           true
@@ -67,23 +96,19 @@ module Dydx
         end
       end
 
-      def common_factors(formula)
-        nil unless formula.is_a?(Formula)
-        if f == formula.f
-          [:f, :f]
-        elsif g == formula.g
-          [:g, :g]
-        elsif f == formula.g
-          [:f, :g]
-        elsif g == formula.f
-          [:g, :f]
-        end
-      end
-
       def commutate!
-        @f, @g = @g, @f
+        @terms.reverse!
         self
       end
+
+      def index(tm)
+        tms.index(tm)
+      end
+
+      def delete(tm)
+        tms.delete(tm)
+        tms.count.one? ? tms.first : self
+      end
     end
   end
 end

data/lib/dydx/algebra/inverse.rb

@@ -29,12 +29,12 @@ module Dydx
         end
       end
 
-      def differentiate(sym=:x)
+      def differentiate(sym = :x)
         case operator
         when :+
           inverse(x.differentiate(sym), :+)
         when :*
-          inverse(x.differentiate(sym) * inverse(x ^ 2, :*), :+)
+          inverse(x.differentiate(sym) * inverse(x ** 2, :*), :+)
         end
       end
       alias_method :d, :differentiate

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

@@ -5,7 +5,6 @@ module Dydx
         include Parts::Base
         include Parts::Formula
         include Parts::General
-        include Parts::Interface
       end
     end
   end

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

@@ -4,7 +4,6 @@ module Dydx
       module General
         include Parts::Base
         include Parts::General
-        include Parts::Interface
       end
     end
   end

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

@@ -5,7 +5,6 @@ module Dydx
         include Parts::Base
         include Parts::Inverse
         include Parts::General
-        include Parts::Interface
       end
     end
   end

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

@@ -5,7 +5,6 @@ module Dydx
         include Parts::Base
         include Parts::Num
         include Parts::General
-        include Parts::Interface
       end
     end
   end

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

@@ -3,9 +3,9 @@ module Dydx
     module Operator
       module Parts
         module Base
-          %w(+ * ^).map(&:to_sym).each do |operator|
+          %w(+ * **).map(&:to_sym).each do |operator|
             define_method(operator) do |x|
-              ::Algebra::Formula.new(self, x, operator.to_sym)
+              ::Algebra::Formula.new(operator.to_sym, self, x)
             end
           end
         end

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

@@ -3,60 +3,81 @@ module Dydx
     module Operator
       module Parts
         module Formula
-          %w(+ *).map(&:to_sym).each do |operator|
-            define_method(operator) do |x|
-              if self.operator == operator
-                if f.combinable?(x, operator)
-                  f.send(operator, x).send(operator, g)
-                elsif g.combinable?(x, operator)
-                  g.send(operator, x).send(operator, f)
+          %w(+ *).map(&:to_sym).each do |op|
+            define_method(op) do |rtm|
+              if operator == op
+                if tms[0].combinable?(rtm, op)
+                  _(
+                    _(tms[0], op, rtm), op, tms[1]
+                  )
+                elsif tms[1].combinable?(rtm, op)
+                  _(
+                    _(tms[1], op, rtm), op, tms[0]
+                  )
                 else
-                  super(x)
+                  super(rtm)
                 end
-              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) && (operator.super.commutative? || w1 == w2)
+              elsif formula?(op.sub) && openable?(op, rtm)
+                _(
+                  _(tms[0], op, rtm), op.sub, _(tms[1], op, rtm)
+                )
+              elsif formula?(op.super) && rtm.formula?(op.super)
+                cmn_fct = (tms & rtm.tms).first
+                return super(rtm) unless cmn_fct
 
-                case operator
-                when :+
-                  send(w1).send(operator.super, send(rest(w1)).send(operator, x.send(rest(w2))))
-                when :*
-                  case w1
-                  when :f
-                    send(w1).send(operator.super, send(rest(w1)).send(operator.sub, x.send(rest(w2))))
-                  when :g
-                    send(w1).send(operator.super, send(rest(w1)).send(operator, x.send(rest(w2)))).commutate!
+                if op.super.commutative?
+                  _(
+                    cmn_fct, op.super, _(delete(cmn_fct), op, rtm.delete(cmn_fct))
+                  )
+                else
+                  return super(rtm) if index(cmn_fct) != rtm.index(cmn_fct)
+
+                  case index(cmn_fct)
+                  when 0
+                    _(
+                      cmn_fct, op.super, _(delete(cmn_fct), op.sub, rtm.delete(cmn_fct))
+                    )
+                  when 1
+                    _(
+                      _(delete(cmn_fct), op, rtm.delete(cmn_fct)), op.super, cmn_fct
+                    )
                   end
                 end
-              elsif formula?(operator.super) && x.inverse?(operator) && x.x.formula?(operator.super)
-                w1, w2 = common_factors(x.x)
-                return super(x) unless (w1 && w2) && (operator.super.commutative? || w1 == w2)
+              elsif formula?(op.super) && rtm.inverse?(op) && rtm.x.formula?(op.super)
+                cmn_fct = (tms & rtm.x.tms).first
+                return super(rtm) unless cmn_fct
 
-                case operator
-                when :+
-                  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(operator.super, send(rest(w1)).send(inverse_ope(operator.sub), x.x.send(rest(w2))))
-                  when :g
-                    send(w1).send(operator.super, send(rest(w1)).send(inverse_ope(operator), x.x.send(rest(w2)))).commutate!
+                if op.super.commutative?
+                  _(
+                    cmn_fct, op.super, _(delete(cmn_fct), op.inv, rtm.x.delete(cmn_fct))
+                  )
+                else
+                  return super(rtm) if index(cmn_fct) != rtm.x.index(cmn_fct)
+                  case index(cmn_fct)
+                  when 0
+                    _(
+                      cmn_fct, op.super, _(delete(cmn_fct), op.sub.inv, rtm.x.delete(cmn_fct))
+                    )
+                  when 1
+                    _(
+                      _(delete(cmn_fct), op.inv, rtm.x.delete(cmn_fct)), op.super, cmn_fct
+                    )
                   end
                 end
               else
-                super(x)
+                super(rtm)
               end
             end
           end
 
-          %w(^).map(&:to_sym).each do |operator|
-            define_method(operator) do |x|
-              if formula?(operator.sub) && openable?(operator, x)
-                f.send(operator, x).send(operator.sub, g.send(operator, x))
+          %w(**).map(&:to_sym).each do |op|
+            define_method(op) do |rtm|
+              if formula?(op.sub) && openable?(op, rtm)
+                _(
+                  _(tms[0], op, rtm), op.sub, _(tms[1], op, rtm)
+                )
               else
-                super(x)
+                super(rtm)
               end
             end
           end