dydx 0.1.314 → 0.1.412

data/spec/lib/function_spec.rb

@@ -1,17 +1,15 @@
 require 'spec_helper'
 
-describe Dydx:Function do
-  before(:each) do
-    reset
-  end
+describe Dydx::Function do
+  before { reset }
 
   it 'ex1' do
     expect(f(x, y)).to eq(f(x, y))
     expect(f(x, y)).to eq($f)
     expect(f(x, y).algebra).to be_nil
     expect(f(x, y).vars).to eq([:x, :y])
-    expect{f(x, y, z)}.to raise_error(ArgumentError)
-    expect{f(x)}.to raise_error(ArgumentError)
+    expect { f(x, y, z) }.to raise_error(ArgumentError)
+    expect { f(x) }.to raise_error(ArgumentError)
   end
 
   it 'ex2' do

data/spec/lib/helper_spec.rb

@@ -3,70 +3,63 @@ require 'spec_helper'
 describe Helper do
   include Helper
   context '#is_n?' do
-    it{ expect(0.is_0?).to be_true }
-    it{ expect(_(0).is_0?).to be_true }
-    it{ expect(inverse(0, :+).is_0?).to be_true }
-    it{ expect(1.is_1?).to be_true }
-    it{ expect(_(1).is_1?).to be_true }
-    it{ expect(inverse(1, :*).is_1?).to be_true }
-    it{ expect(-1.is_minus1?).to be_true }
-    it{ expect(_(-1).is_minus1?).to be_true }
+    it { expect(0.zero?).to be true }
+    it { expect(_(0).zero?).to be true }
+    it { expect(inverse(0, :+).zero?).to be true }
+    it { expect(1.one?).to be true }
+    it { expect(_(1).one?).to be true }
+    it { expect(inverse(1, :*).one?).to be true }
+    it { expect(-1.minus1?).to be true }
+    it { expect(_(-1).minus1?).to be true }
   end
 
-  context '#is_multiple_of' do
-    it{ expect(0.is_multiple_of(:x).to_s).to eq('0') }
-    it{ expect(_(0).is_multiple_of(:y).to_s).to eq('0')}
+  context '#multiple_of?' do
+    it { expect(0.multiple_of?(x)).to be(true) }
 
-    it{ expect(:x.is_multiple_of(:x).to_s).to eq('1') }
-    it{ expect(:x.is_multiple_of(:y)).to be_false }
+    it { expect(4.multiple_of?(_(2))).to be(true) }
+    it { expect(_(4).multiple_of?(2)).to be(true) }
+    it { expect(_(4).multiple_of?(_(2))).to be(true) }
 
-    it{ expect((:x * :y).is_multiple_of(:x)).to eq(:y) }
-    it{ expect((:x * :y).is_multiple_of(:y)).to eq(:x) }
-    it{ expect((:x * :y).is_multiple_of(:z)).to be_false }
+    it { expect(x.multiple_of?(x)).to be(true) }
+    it { expect(x.multiple_of?(y)).to be(false) }
+
+    it { expect((x * y).multiple_of?(x)).to be(true) }
+    it { expect((x * y).multiple_of?(x)).to be(true) }
+    it { expect((x * y).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 }
+    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 }
-    it{ expect((2 * :x).combinable?(:x, :+)).to be_true }
-    it{ expect((2 * :x).combinable?(2 * :x, :+)).to be_true }
-    it{ expect(:x.combinable?(:y, :+)).to be_false }
-    it{ expect(1.combinable?(2, :+)).to be_true }
-    it{ expect(:x.combinable?(:x, :*)).to be_true }
-    it{ expect(:x.combinable?(:y, :*)).to be_false }
-    it{ expect(1.combinable?(2, :*)).to be_true }
-    it{ expect(0.combinable?(:x, :^)).to be_true }
-    it{ expect(1.combinable?(:y, :^)).to be_true }
+    it { expect(:x.combinable?(:x, :+)).to be true }
+    it { expect(:x.combinable?(2 * :x, :+)).to be true }
+    it { expect((2 * :x).combinable?(:x, :+)).to be true }
+    it { expect((2 * :x).combinable?(2 * :x, :+)).to be true }
+    it { expect(:x.combinable?(:y, :+)).to be false }
+    it { expect(1.combinable?(2, :+)).to be true }
+    it { expect(:x.combinable?(:x, :*)).to be true }
+    it { expect(:x.combinable?(:y, :*)).to be false }
+    it { expect(1.combinable?(2, :*)).to be true }
+    it { expect(0.combinable?(:x, :**)).to be true }
+    it { expect(1.combinable?(:y, :**)).to be true }
   end
 
   context '#distributive?' do
-    it{ expect(distributive?(:+, :*)).to be_true }
-    it{ expect(distributive?(:+, :/)).to be_true }
-    it{ expect(distributive?(:-, :*)).to be_true }
-    it{ expect(distributive?(:-, :/)).to be_true }
-    it{ expect(distributive?(:*, :^)).to be_true }
-    it{ expect(distributive?(:/, :^)).to be_true }
-    it{ expect(distributive?(:*, :+)).to be_false }
-    it{ expect(distributive?(:^, :*)).to be_false }
+    it { expect(distributive?(:+, :*)).to be true }
+    it { expect(distributive?(:+, :/)).to be true }
+    it { expect(distributive?(:-, :*)).to be true }
+    it { expect(distributive?(:-, :/)).to be true }
+    it { expect(distributive?(:*, :**)).to be true }
+    it { expect(distributive?(:/, :**)).to be true }
+    it { expect(distributive?(:*, :+)).to be false }
+    it { expect(distributive?(:**, :*)).to be false }
   end
 
-  let(:addition)      { (:x + :y) }
-  let(:subtraction)   { (:x - :y) }
-  let(:multiplication){ (:x * :y) }
-  let(:division)      { (:x / :y) }
-  let(:exponentiation){ (:x ^ :y) }
-
-  it{ expect(addition.addition?).to be_true }
-  it{ expect(multiplication.multiplication?).to be_true }
-  it{ expect(exponentiation.exponentiation?).to be_true }
-
-  it{ expect(inverse(:x, :+).inverse?(:+, :x)).to be_true }
-  it{ expect(:x.inverse?(:+, inverse(:x, :+))).to be_true }
-  it{ expect(inverse(:x, :*).inverse?(:*, :x)).to be_true }
-  it{ expect(:x.inverse?(:*, inverse(:x, :*))).to be_true }
+  it { expect(inverse(x, :+).inverse?(:+, x)).to be true }
+  it { expect(x.inverse?(:+, inverse(x, :+))).to be true }
+  it { expect(inverse(x, :*).inverse?(:*, x)).to be true }
+  it { expect(x.inverse?(:*, inverse(x, :*))).to be true }
 end

data/spec/lib/integrand_spec.rb

@@ -1,16 +1,14 @@
 require 'spec_helper'
 
-describe Dydx:Integrand do
-  before(:each) do
-    reset
-  end
+describe Dydx::Integrand do
+  before { reset }
 
   it 'ex1' do
     f(x, y) <= x * y
     integrand = S(f(x, y), dx)
     expect(integrand.function).to eq(f(x, y))
-    expect(integrand.var).to eq(:x)
-    expect{integrand[4, 3]}.to raise_error(ArgumentError)
+    expect(integrand.var).to eq(x)
+    expect { integrand[4, 3] }.to raise_error(ArgumentError)
   end
 
   it 'ex2' do
@@ -34,20 +32,24 @@ describe Dydx:Integrand do
   end
 
   it 'ex6' do
-    f(x) <= e ^ (- (x ^ 2))
+    f(x) <= e ** -x ** 2
     expect(f(0)).to eq(1)
-    expect(f(1)).to eq(1.0/Math::E)
+    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.77239273)
   end
 
   it 'ex7' do
-    f(x) <= (1.0 / ( ( 2.0 * Math::PI ) ^ 0.5 ) ) * ( e ^ (- (x ^ 2) / 2) )
+    f(x) <= (1.0 / ( 2.0 * Math::PI ) ** 0.5) * e ** (- x ** 2 / 2)
     expect(S(f(x), dx)[-1000, 1000]).to eq(1.0)
   end
 
   it 'ex8' do
-    f(x) <= (1.0 / ( ( 2.0 * Math::PI ) ^ 0.5 ) ) * ( e ^ (- (x ^ 2) / 2) )
+    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
+
+  it 'ex9' do
+    expect(S(log(x), dx)[0, 1]).to eq(-oo)
+  end
 end

data/spec/spec_helper.rb

@@ -1,4 +1,5 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'dydx'
 require 'pry'
-include Dydx
+
+include Dydx

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dydx
 version: !ruby/object:Gem::Version
-  version: 0.1.314
+  version: 0.1.412
 platform: ruby
 authors:
 - gogotanaka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-01 00:00:00.000000000 Z
+date: 2014-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -55,7 +55,7 @@ dependencies:
 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
+- mail@tanakakazuki.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -63,6 +63,7 @@ files:
 - ".gitignore"
 - ".pryrc"
 - ".rspec"
+- ".rubocop.yml"
 - ".travis.yml"
 - Gemfile
 - LICENSE.txt
@@ -77,11 +78,9 @@ files:
 - 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
-- lib/dydx/algebra/operator/parts/interface.rb
 - lib/dydx/algebra/operator/parts/inverse.rb
 - lib/dydx/algebra/operator/parts/num.rb
 - lib/dydx/algebra/operator/parts/symbol.rb
@@ -102,7 +101,7 @@ files:
 - spec/lib/helper_spec.rb
 - spec/lib/integrand_spec.rb
 - spec/spec_helper.rb
-homepage: https://github.com/gogotanaka
+homepage: http://gogotanaka.me/
 licenses:
 - MIT
 metadata: {}
@@ -122,7 +121,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.1
 signing_key: 
 specification_version: 4
 summary: We can enjoy the math.

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

@@ -1,6 +0,0 @@
-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/interface.rb

@@ -1,22 +0,0 @@
-module Dydx
-  module Algebra
-    module Operator
-      module Parts
-        module Interface
-          %w(+ - * / ^).map(&:to_sym).each do |operator|
-            define_method(operator) do |x|
-              x = ::Set::Num.new(x) if x.is_a?(Fixnum)
-              if operator == :/ && x.is_0?
-                raise ZeroDivisionError
-              elsif [:-, :/].include?(operator)
-                send(inverse_ope(operator), inverse(x, inverse_ope(operator)))
-              else
-                super(x)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end