dydx 0.1.3 → 0.1.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 79327c9edd590f2a006eb29d8b148919d913c9a4
+  data.tar.gz: d5b7e817ffe55271c3a473d3b1679b3abaa929ee
+SHA512:
+  metadata.gz: 5716ffe76bc6e49af3ef2560920cebc20845b01ec1be35ca6b46a4a454530b1582a9820add4c6a2b0a29bfc84e26751133faea9c5c277c19fd1f5f9b8c8c842b
+  data.tar.gz: f5dd91eb57c7ac6d6a3dd8a8318b98953295d4de7fb67c530fad3c040b351e225c1a79da03fe4bbb51110545a572fb8ba194de715a34f8ce96a1d6b627c7e4bd

data/.pryrc

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

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/Gemfile

@@ -1,5 +1,8 @@
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in dydx.gemspec
+gem 'rubocop'
 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.
 
@@ -17,29 +19,31 @@ require 'dydx'
 include Dydx
 
 # Define the function. syntax is not good enough...
-f(x) <= x ^ 2
+f(x, y) <= x + x*y + y
 
-f(3)
-=> 9
+# simplify
+f(x, y) == x * (1 + y) + y
+=> true
 
-f(x).to_s
-=> "( x ^ 2 )"
+#part substitution
+f(a, 2) == 3*a + 2
+=> true
 
-f(x) == eval('f(x).to_s')
+f(1, a + b) == 1 + 2 * ( a + b )
 => true
 
+
 # Differentiate
-g(x) <= d/dx(f(x))
+d/dx(f(x, y)) == 1 + y
+=> true
 
-g(3)
-=> 6
+g(x) <= sin(x)
 
-g(x).to_s
-=> '2 * x'
+d/dx(g(x)) == cos(x)
 
 # Integrate
-S(f(x), dx)[0, 1]
-=> 0.3333333333333334
+S(g(x), dx)[0, pi/2]
+=> 1.0
 ```
 
 
@@ -50,57 +54,21 @@ f(z) <= log(z)
 S(f(z), dz)[0,1]
 => -Infinity
 
-( d/dx(log(x)) ).to_s
-=> "( 1 / x )"
-
-( d/dx(cos(x)) ).to_s
-=> "( - sin( x ) )"
+d/dx(log(x)) == 1 / x
+=> true
 
-( d/dx(e ^ x) ).to_s
-=> "( e ^ x )"
+d/dx(cos(x)) == -cos(x)
+=> true
 
-f(x) <= sin(x)
-S(f(x), dx)[0, Math::PI/2]
-=> 1.000000000021139
+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]
-=> 0.9952054164466917
+=> 1.0
 ```
 
-#### it's like a magic...
-
-```ruby:
-f(x) <= x ^ 2
-
-f(a + b).to_s
-=> "( ( a + b ) ^ 2 )"
-
-#↓it"s magic!!!
-g(a, b) <= f(a + b)
-
-g(a, b).to_s
-=> "( ( a + b ) ^ 2 )"
-
-g(2, 2)
-=> 16
-
-( d/da(g(a, b)) ).to_s
-=> "( 2 * ( a + b ) )"
-
-# simplify
-((x * y) + (z * x)).to_s
-=> "( x * ( y + z ) )"
-
-((x ^ y) / (x ^ z)).to_s
-=> "( x ^ ( y - z ) )"
-
-(x + x).to_s
-=> "( 2 * x )"
-```
-
-
 ## Documents
 I'm going to write now...cominng soon....
 
@@ -109,14 +77,11 @@ I'm going to write now...cominng soon....
 ```
 Dydx
   |- Algebra
-  |      |- Set
-  |      |   |- Num
-  |      |   |- ....
-  |      |
   |      |- Operator
   |      |   |- Interface
   |      |   |- ....
   |      |
+  |      |- Set
   |      |- Formula
   |      |- inverse
   |
@@ -156,6 +121,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/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         = ['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.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,18 +6,20 @@ require 'dydx/integrand'
 
 module Dydx
   include Algebra
-  %w(f g h).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
 
-      string = substitute(vars, function)
-      string = rename_for_calc(string) if all_vars_num?(vars)
-      eval(string)
+      subst_hash = Hash[*[function.vars, vars].transpose.flatten]
+      begin
+        function.algebra.subst(subst_hash).to_f
+      rescue ArgumentError
+        eval(function.algebra.subst(subst_hash).to_s)
+      end
     end
   end
 
@@ -33,6 +35,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.$/
@@ -43,26 +56,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,89 +1,21 @@
-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, :-
-        alias_method :multiplication, :*
-        alias_method :division, :/
-        alias_method :exponentiation, :**
-        ope_to_str = {
-          addition: :+,
-          subtraction: :-,
-          multiplication: :*,
-          division: :/,
-          exponentiation: :^
-        }
-        %w(+ - * / ^).each do |operator|
-          define_method(operator) do |g|
-            if g.is_a?(Symbol) ||
-              g.is_a?(Formula) ||
-              g.is_a?(Base)
-
-              Num.new(self).send(operator.to_sym, g)
-            else
-              send(ope_to_str.key(operator.to_sym), g)
-            end
-          end
-        end
-      end
 
-      Float.class_eval do
-        alias_method :addition, :+
-        alias_method :subtraction, :-
-        alias_method :multiplication, :*
-        alias_method :division, :/
-        alias_method :exponentiation, :**
-        ope_to_str = {
-          addition: :+,
-          subtraction: :-,
-          multiplication: :*,
-          division: :/,
-          exponentiation: :^
-        }
-        %w(+ - * / ^).each do |operator|
-          define_method(operator) do |g|
-            if g.is_a?(Symbol) ||
-              g.is_a?(Formula) ||
-              g.is_a?(Base)
-
-              Num.new(self).send(operator.to_sym, g)
-            else
-              send(ope_to_str.key(operator.to_sym), g)
-            end
-          end
-        end
-      end
-      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 Sin;    include Operator::General; end
-      class Cos;    include Operator::General; end
-      class Tan;    include Operator::General; end
-    end
     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 trs
+        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,17 +50,29 @@ 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
 
+      def subst(hash = {})
+        f.subst(hash).send(operator, g.subst(hash))
+      end
+
+      def to_f
+        f.to_f.send(operator, g.to_f)
+      end
+
       def include?(x)
         f == x || g == x
       end
@@ -49,28 +82,33 @@ module Dydx
         (f.combinable?(x, operator) || g.combinable?(x, operator))
       end
 
-      # TODO: interchangeable
+      def rationals
+        [f, g].select{ |term| term.num? && term.n.is_a?(Rational) }
+      end
+
       def ==(x)
-        to_s == x.to_s
-      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]
+        if to_s == x.to_s
+          true
+        else
+          result = commutate!.to_s == x.to_s
+          commutate!
+          result
         end
       end
 
       def commutate!
-        @f, @g = @g, @f
+        @terms.reverse!
         self
       end
+
+      def index(tr)
+        trs.index(tr)
+      end
+
+      def delete(tr)
+        trs.delete(tr)
+        trs.count.one? ? trs.first : self
+      end
     end
   end
 end