dydx 0.1.4 → 0.1.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 79327c9edd590f2a006eb29d8b148919d913c9a4
-  data.tar.gz: d5b7e817ffe55271c3a473d3b1679b3abaa929ee
+  metadata.gz: 50e18dda6ca41f30bb45fdbc2f73c906c6e01c94
+  data.tar.gz: 14094dd2083a888d715e93eb0a1faa8aa6f9cf13
 SHA512:
-  metadata.gz: 5716ffe76bc6e49af3ef2560920cebc20845b01ec1be35ca6b46a4a454530b1582a9820add4c6a2b0a29bfc84e26751133faea9c5c277c19fd1f5f9b8c8c842b
-  data.tar.gz: f5dd91eb57c7ac6d6a3dd8a8318b98953295d4de7fb67c530fad3c040b351e225c1a79da03fe4bbb51110545a572fb8ba194de715a34f8ce96a1d6b627c7e4bd
+  metadata.gz: abbe8199d94ede3e5568aaf41c5d4dba0996af0b2da53e8313372d96d67c401c64e802f30777995f92fc966cb4e81740ffae5228ce352f711856793615435d3c
+  data.tar.gz: 12087ca360a5da0e9fa6c32ed5818d8b40c3044a1f9efa2da4bbf75772fad9794a5b7660eb6239009c051ebe30ac7f8ef293611caf16b3610c265709a6f5e7c8

data/Gemfile

@@ -1,8 +1,5 @@
 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,94 +1,157 @@
-# Dydx is new MATH Language on Ruby.
+# Dydx
+It always happens you want to differentiate some formulas with ruby. right?.....
 
-### Since you report a bug, I will fix it within 24 hours.
-
-The most important thing in this DSL is
+After `inlcude Dydx` , ruby become like other language.
 
-we can handle math in the same sense sense of the math on paper.
+## Dydx is new math DSL in Ruby
 
-ex. limit, trigonometric functions and logarithmic.
+I'm going to add for more explanation.
 
-## We should enjoy MATH even using PC.
-(to say nothing of using pen.)
 
-After `inlcude Dydx` , ruby become like other language.
 
-## Outline
 ```ruby:
 require 'dydx'
 include Dydx
 
-# Define the function. syntax is not good enough...
-f(x, y) <= x + x*y + y
+f(x) <= x ^ 2
+
+f(3)
+# => 9
+
+f(x).to_s
+# => "( x ^ 2 )"
+
+f(x) == eval('f(x).to_s')
+# => true
 
-# simplify
-f(x, y) == x * (1 + y) + y
-=> true
+g(x) <= d/dx(f(x))
 
-#part substitution
-f(a, 2) == 3*a + 2
-=> true
+g(3)
+# => 6
 
-f(1, a + b) == 1 + 2 * ( a + b )
-=> true
+# => '2 * x'
 
+S(f(x), dx)[0, 1]
+# => 0.3333333333333334
+
+( d/dx(log(x)) ).to_s
+# => "( 1 / x )"
+
+( d/dx(cos(x)) ).to_s
+# => "( - sin( x ) )"
+
+( d/dx(e ^ x) ).to_s
+# => "( e ^ x )"
+
+f(x) <= sin(x)
+S(f(x), dx)[0, Math::PI/2]
+# => 1.000000000021139
+
+f(x) <= (1.0 / ( ( 2.0 * pi ) ^ 0.5 ) ) * ( e ^ (- (x ^ 2) / 2) )
+S(f(x), dx)[-oo, oo]
+# => 0.9952054164466917
 
-# Differentiate
-d/dx(f(x, y)) == 1 + y
-=> true
+f(x) <= x ^ 2
 
-g(x) <= sin(x)
+f(a + b).to_s
+# => "( ( a + b ) ^ 2 )"
 
-d/dx(g(x)) == cos(x)
+g(a, b) <= f(a + b)
 
-# Integrate
-S(g(x), dx)[0, pi/2]
-=> 1.0
+g(a, b).to_s
+# => "( ( a + b ) ^ 2 )"
+
+g(2, 2)
+# => 16
+
+( d/da(g(a, b)) ).to_s
+=> "( 2 * ( a + b ) )"
 ```
 
 
-#### limit, trigonometric functions and logarithmic.
-```ruby:
 
-f(z) <= log(z)
-S(f(z), dz)[0,1]
-=> -Infinity
 
-d/dx(log(x)) == 1 / x
-=> true
 
-d/dx(cos(x)) == -cos(x)
-=> true
+```
+require 'dydx'
+include Dydx
 
-d/dx(e ** x) == e ** x
-=> true
+# There are three types of differential interface
+
+( d/dx(x^2) ).to_s
+=> "( 2 * x )"
+
+log(z).d(z).to_s
+=> "( 1 / z )"
+
+$y = e ^ x
+(dy/dx).to_s
+=> "( e ^ x )"
 
-# standard normal distribution;
-f(x) <= (1.0 / ( 2.0 * pi ) ** 0.5) * e ** (- x ** 2 / 2)
-S(f(x), dx)[-oo, oo]
-=> 1.0
 ```
 
-## Documents
-I'm going to write now...cominng soon....
+You may wonder why undefined `x` , `e` and `z` are handleable?
+
+`method_missing` solve this problem by converting undefine variable into internal class object.
 
-### Module, class configuration
+Like this.
 
 ```
-Dydx
-  |- Algebra
-  |      |- Operator
-  |      |   |- Interface
-  |      |   |- ....
-  |      |
-  |      |- Set
-  |      |- Formula
-  |      |- inverse
-  |
-  |- Function
-  |- Delta
-  |- Integrand
+ x + x
+=> #<Dydx::Algebra::Formula:0x007fb0a4039fb0 @f=#<Dydx::Algebra::Set::Num:0x007fb0a48169e0 @n=2>, @operator=:*, @g=:x>
+
+e
+=> #<Dydx::Algebra::Set::E:0x007fb0a383e9f0>
+
+log(sin(x))
+=> #<Dydx::Algebra::Set::Log:0x007fe7cd971528 @f=#<Dydx::Algebra::Set::Sin:0x007fe7cd971550 @x=:x>>
+```
+
+And this DSL has strong 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 )"
+```
+
+I show some differential calculus.
+
 ```
+# pretermit '#to_s'
+
+d/dz(log(z))
+=> "( 1 / z )"
+
+d/dx(x^n)
+=> "( n * ( x ^ ( n - 1 ) ) )"
+
+$y = cos(x)
+dy/dx
+=> "( - sin( x ) )"
+
+$x = a * ( (t ^ 2) / 2 )
+dx/dt
+=> "( a * t )"
+
+d/dt(dx/dt)
+=>"a"
+
+((x ^ 2) * y).d(x)
+=> "( ( 2 * x ) * y )"
+
+((x ^ 2) * y).d(x).d(y)
+=> "( 2 * x )"
+
+```
+
+
+(That's wonderful!!!!! ..............)
 
 ## Installation
 
@@ -121,6 +184,6 @@ Or install it yourself as:
 run `bundle exec rake spec`
 
 ```
-Finished in 3.76 seconds
-325 examples, 0 failures
+Finished in 3.23 seconds
+309 examples, 0 failures
 ```

data/Rakefile

@@ -1,10 +1,13 @@
-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 `rake spec`
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ["-c", "-fs"]
+end
 
 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 derivative.}
+  spec.description   = %q{It is possible to use the differential using the Symbol and Fixnum by including the Dydx. And, we can use the natural logarithm and log.}
 
-  spec.license       = 'MIT'
+  spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
-  spec.require_paths = ['lib']
+  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.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,19 +6,32 @@ require 'dydx/integrand'
 
 module Dydx
   include Algebra
-  %w(f g h temp_cal_f).each do |functioner|
+  # TODO: Refactor
+  %w(f g h).each do |functioner|
     define_method(functioner) do |*vars|
-      function = eval("$#{functioner}")
-      return eval("$#{functioner} = Function.new(*vars)") unless function
-
-      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
-        function.algebra.subst(subst_hash).to_f
-      rescue ArgumentError
-        eval(function.algebra.subst(subst_hash).to_s)
+      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
     end
   end
@@ -35,17 +48,6 @@ 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.$/

data/lib/dydx/algebra.rb

@@ -1,21 +1,89 @@
+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 x.num?
-        x = x.to_numeric
-        if operator == :+
-          _(- x)
-        else
-          _(Rational(1, x))
-        end
+      if operator == :+ && x.is_0?
+        e0
+      elsif operator == :* && x.is_1?
+        e1
       elsif x.is_a?(Inverse) && x.operator == operator
         x.x
       else