dydx 0.1.2 → 0.1.3

data/README.md

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

data/dydx.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   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.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"
 

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
 
@@ -44,6 +29,10 @@ module Dydx
     Delta.new
   end
 
+  def reset
+    $f, $g, $h = nil, nil, nil
+  end
+
   def method_missing(method, *args, &block)
     method_name = method.to_s
     if method_name =~ /^d.$/
@@ -54,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/formula.rb

@@ -5,15 +5,14 @@ module Dydx
       attr_accessor :f, :operator, :g
 
       def initialize(f, g, operator)
+        g, f = f, g if g.is_num? && operator.commutative?
         @f, @g, @operator = f, g, operator
       end
 
       def differentiate(sym=:x)
         case @operator
-        when :+
-          f.d(sym) + g.d(sym)
-        when :*
-          (f.d(sym) * g) + (f * g.d(sym))
+        when :+ then f.d(sym) + g.d(sym)
+        when :* then (f.d(sym) * g) + (f * g.d(sym))
         when :^
           # TODO:
           if g.is_num?
@@ -30,18 +29,14 @@ module Dydx
       alias_method :d, :differentiate
 
       def to_s
-        if (multiplication? && (f.is_minus1? || g.is_minus1?)  )
+        if (formula?(:*) && (f.is_minus1? || g.is_minus1?)  )
           "( - #{g.to_s} )"
-        elsif multiplication? && g.inverse?(:*)
-          "( #{f.to_s} / #{g.x.to_s} )"
-        elsif multiplication? && f.inverse?(:*)
-          "( #{g.to_s} / #{f.x.to_s} )"
-        elsif addition? && g.inverse?(:+)
-          "( #{f.to_s} - #{g.x.to_s} )"
-        elsif addition? && f.inverse?(:+)
-          "( #{g.to_s} - #{f.x.to_s} )"
+        elsif g.inverse?(operator)
+          "( #{f.to_s} #{inverse_ope(operator)} #{g.x.to_s} )"
+        elsif f.inverse?(operator)
+          "( #{g.to_s} #{inverse_ope(operator)} #{f.x.to_s} )"
         else
-          "( #{f.to_s} #{@operator} #{g.to_s} )"
+          "( #{f.to_s} #{operator} #{g.to_s} )"
         end
       end
 

data/lib/dydx/algebra/inverse.rb

@@ -9,12 +9,9 @@ module Dydx
       end
 
       def to_s
-        # sym = {'*'=>'/', '+'=>'-'}[operator.to_s]
         case operator
-        when :+
-          "( - #{x} )"
-        when :*
-          "( 1 / #{x} )"
+        when :+ then "( - #{x} )"
+        when :* then "( 1 / #{x} )"
         end
       end
 
@@ -27,10 +24,6 @@ module Dydx
         end
       end
       alias_method :d, :differentiate
-
-      def ==(x)
-        to_s == x.to_s
-      end
     end
   end
-end
+end

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

@@ -13,6 +13,8 @@ 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))
                 w1, w2 = common_factors(x)
                 return super(x) unless (w1 && w2) && (super_ope(operator).commutative? || w1 == w2)
@@ -49,11 +51,13 @@ module Dydx
             end
           end
 
-          def ^(x)
-            if multiplication? && openable?(:^, x)
-              (f ^ x).send(self.operator, (g ^ x))
-            else
-              super(x)
+          %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))
+              else
+                super(x)
+              end
             end
           end
         end

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

@@ -43,8 +43,8 @@ module Dydx
                 else
                   super(x)
                 end
-              elsif [:*].include?(operator) && x.inverse?(:+)
-                inverse(::Algebra::Formula.new(self, x.x, operator.to_sym), :+)
+              elsif operator == :* && x.inverse?(:+)
+                -(self * x.x)
               else
                 super(x)
               end

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

@@ -4,7 +4,7 @@ module Dydx
       module Parts
         module Symbol
           def *(x)
-            if x.exponentiation? &&
+            if x.formula?(:^) &&
               self == x.f
 
               self ^ (1 + x.g)

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

@@ -16,10 +16,6 @@ module Dydx
         def to_s
           @n.to_s
         end
-
-        def ==(x)
-          to_s == x.to_s
-        end
       end
     end
   end

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

@@ -12,10 +12,11 @@ module Dydx
           "sin( #{x.to_s} )"
         end
 
-        def d(sym=:x)
+        def differentiate(sym=:x)
           cos(x) * x.d(sym)
         end
+        alias_method :d, :differentiate
       end
     end
   end
-end
+end

data/lib/dydx/helper.rb

@@ -61,10 +61,9 @@ module Dydx
     def combinable?(x, operator)
       case operator
       when :+
-        self == x ||
         (is_num? && x.is_num?) ||
-        (multiplication? && (f == x || g == x)) ||
-        (x.multiplication? && (x.f == self || x.g == self)) ||
+        (formula?(:*) && (f.is_num? || g.is_num?)) && x.is_num? ||
+        like_term?(x) ||
         inverse?(:+, x)
       when :*
         self == x ||
@@ -75,6 +74,18 @@ module Dydx
       end
     end
 
+    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
@@ -100,9 +111,6 @@ module Dydx
       ([:f, :g] - [f_or_g]).first
     end
 
-    def commutative?
-    end
-
     def distributable?(operator)
     end
 

data/lib/dydx/version.rb

@@ -1,3 +1,3 @@
 module Dydx
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/spec/dydx_spec.rb

@@ -17,8 +17,8 @@ describe Dydx do
     $b = (:x ^ (:x * 2))
     let(:d1){ db/dx }
     let(:d2){ d/dx($b) }
-    it{ expect(d1.to_s).to eq('( ( x * 2 ) * ( x ^ ( ( x * 2 ) - 1 ) ) )') }
-    it{ expect(d2.to_s).to eq('( ( x * 2 ) * ( x ^ ( ( x * 2 ) - 1 ) ) )') }
+    it{ expect(d1.to_s).to eq('( ( 2 * x ) * ( x ^ ( ( 2 * x ) - 1 ) ) )') }
+    it{ expect(d2.to_s).to eq('( ( 2 * x ) * ( x ^ ( ( 2 * x ) - 1 ) ) )') }
   end
 
   context 'ex3' do

data/spec/lib/algebra/operator/parts/formula_spec.rb

@@ -47,10 +47,17 @@ describe Dydx::Algebra::Operator::Parts::Formula do
   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 * 2) ^ 2).to_s).to eq('( ( x ^ 2 ) * 4 )') }
+  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 ) ) )') }
+
   # TODO:
-  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

data/spec/lib/function_spec.rb

@@ -28,8 +28,8 @@ describe Dydx:Function do
 
   it{ expect(h(a, b, c) <= d/db(g(a, b))).to eq(h(a, b, c)) }
   it{ expect(h(a, b, c) <= d/db(g(a, b))).to eq($h) }
-  it{ expect(h(a, b, c)).to eq(( ( 2 * b ) + a )) }
-  it{ expect(h(a, b, c).algebra).to eq(( ( 2 * b ) + a )) }
+  it{ expect(h(a, b, c)).to eq(( a + ( 2 * b ) )) }
+  it{ expect(h(a, b, c).algebra).to eq(( a + ( 2 * b ) )) }
 
   it 'ex.4' do
     $f = nil

data/spec/lib/helper_spec.rb

@@ -25,6 +25,11 @@ describe Helper do
     it{ expect((:x * :y).is_multiple_of(:z)).to be_false }
   end
 
+  context '#like_term?' do
+    it{ expect(x.like_term?(x)).to be_true }
+    it{ expect((2 * x).like_term?((3 * x))).to be_true }
+  end
+
   context '#combinable?' do
     it{ expect(:x.combinable?(:x, :+)).to be_true }
     it{ expect(:x.combinable?(2 * :x, :+)).to be_true }

data/spec/lib/integrand_spec.rb

@@ -1,8 +1,11 @@
 require 'spec_helper'
 
 describe Dydx:Integrand do
+  before(:each) do
+    reset
+  end
+
   it 'ex1' do
-    $f = nil
     f(x, y) <= x * y
     integrand = S(f(x, y), dx)
     expect(integrand.function).to eq(f(x, y))
@@ -11,31 +14,26 @@ describe Dydx:Integrand do
   end
 
   it 'ex2' do
-    $f = nil
     f(x) <= x * x
     expect(S(f(x), dx)[0, 1]).to eq(0.3333333333333334)
   end
 
   it 'ex3' do
-    $f = nil
     f(x) <= sin(x)
     expect(S(f(x), dx)[0, Math::PI/2]).to eq(1.000000000021139)
   end
 
   it 'ex4' do
-    $f = nil
     f(x) <= cos(x)
     expect(S(f(x), dx)[0, Math::PI]).to eq(7.440786129085082e-17)
   end
 
   it 'ex5' do
-    $f = nil
     f(x) <= log(x)
     expect(S(f(x), dx)[0, 1]).to eq(-oo)
   end
 
   it 'ex6' do
-    $f = nil
     f(x) <= e ^ (- (x ^ 2))
     expect(f(0)).to eq(1)
     expect(f(1)).to eq(1.0/Math::E)
@@ -44,13 +42,11 @@ describe Dydx:Integrand do
   end
 
   it 'ex7' do
-    $f = nil
     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)
   end
 
   it 'ex8' do
-    $f = nil
     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)
   end

metadata

@@ -1,68 +1,75 @@
 --- !ruby/object:Gem::Specification
 name: dydx
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
+  prerelease: 
 platform: ruby
 authors:
 - gogotanaka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-26 00:00:00.000000000 Z
+date: 2014-05-28 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: 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.
+description: 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.
 email:
 - qlli.illb@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rspec"
-- ".travis.yml"
+- .gitignore
+- .rspec
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -125,27 +132,34 @@ 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: 1610563563432672313
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - ">="
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 1610563563432672313
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 1.8.23
 signing_key: 
-specification_version: 4
-summary: We can enjoy the derivative.
+specification_version: 3
+summary: We can enjoy the math.
 test_files:
 - spec/dydx_spec.rb
 - spec/lib/algebra/formula_spec.rb

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: 05d9adcc67c3ad1cbaf217f11bf2d71a5926588a
-  data.tar.gz: bd230293d17b20bf98ab7b6af22d03a544454f15
-SHA512:
-  metadata.gz: 96db75da9bb34f1dd34b4f7dc725d380031fd3092d93062e7d9289a41c35132612521ece1e3770ed0649f3c936ebd0daea965b13465a9c060f7b63258e7aa882
-  data.tar.gz: 47038bba5523d403d3f07153e22236e6f71d15846256d9f2db0772bf679834ac4c0b3ec9a16bd2b86f953ad268ee831e9fb9c6257529e4fe2b35046befafebd5