malge 0.0.6 → 0.0.7

data/CHANGES

@@ -1,6 +1,14 @@
 = vasputils changelog
 
-== Master (for 0.0.7)
+== Master (for 0.0.8)
+
+== Version 0.0.7)
+* Add Malge::ErrorFittedFunction::AXInv2
+* Add Malge::ErrorFittedFunction::AXInv3
+* Malge::ErrorFittedFunction may raise UnableCalculationError if contain not finit value in coefficients after fitting.
+* Debug Malge::ErrorFittedFunction; to delete finest value.
+* Obsolete Malge::ErrorFittedFunction#finest_y; Use Malge::ErrorFittedFunction#most_strict_pairs alternatively.
+* Change behavior of Malge::ErrorFittedFunction when generated; To keep the most precise value pair.
 
 == Version 0.0.6)
 * Rename Malge::ErrorFittedFunction::AXInv to Malge::ErrorFittedFunction::AXInvPlusB

data/Gemfile

@@ -10,5 +10,5 @@ group :development do
   gem "bundler", "~> 1.2.2"
   gem "jeweler", "~> 1.8.3"
   gem "simplecov", ">= 0"
-  gem "psych", ">= 0"
+  #gem "psych", ">= 0"
 end

data/VERSION

@@ -1 +1 @@
-0.0.6
+0.0.7

data/lib/malge.rb

@@ -5,8 +5,8 @@ require "malge/errorfittedfunction/aexpbx.rb"
 require "malge/errorfittedfunction/aexpbx32.rb"
 require "malge/errorfittedfunction/axinv.rb"
 require "malge/errorfittedfunction/axinv32.rb"
-require "malge/errorfittedfunction/axinvplusb.rb"
-require "malge/errorfittedfunction/axinv32plusb.rb"
+require "malge/errorfittedfunction/axinv2.rb"
+require "malge/errorfittedfunction/axinv3.rb"
 require "malge/leastsquare.rb"
 require "malge/matrix.rb"
 require "malge/simultaneousequations.rb"

data/lib/malge/errorfittedfunction.rb

@@ -12,6 +12,7 @@ class Malge::ErrorFittedFunction
   class TypeError < Exception; end
   class SizeMismatchError < Exception; end
   class NotImplementedError < Exception; end
+  class UnableCalculationError < Exception; end
 
   #Generate error fitted function from x[i] and y[i].
   #Errors are generated y[i] and y_true assumed by the expected most precise y[i].
@@ -24,15 +25,18 @@ class Malge::ErrorFittedFunction
     end
 
     @raw_pairs = data_pairs
-    @diff_abs_pairs = data_pairs.map { |pair| [pair[0], (pair[1] - finest_y).abs] }
-    @diff_abs_pairs.delete_at(-1)
+    @diff_abs_pairs = data_pairs.map { |pair| [pair[0], (pair[1] - most_strict_pair[1]).abs] }
     fit
+
+    @coefficients.each do |coef|
+      raise UnableCalculationError unless coef.finite?
+    end
   end
 
-  ##Return expected error 
-  #def expected_errors(x)
-  #  raise NotImplementedError, "Define #{__method__}() in the inherited class."
-  #end
+  #Return string which is easily readable for people to know the function.
+  def equation
+    raise NotImplementedError, "Define #{__method__}() in the inherited class."
+  end
 
   #Return expected error at x, condition variable, on the fitted function.
   #Note that this method does not return the error between actual and true value.
@@ -47,9 +51,7 @@ class Malge::ErrorFittedFunction
   #Ignore last value of x[i] and y[i].
   def variance
     sum = 0.0
-    #pp @diff_abs_pairs
     @diff_abs_pairs.each do |pair|
-      #pp pair
       sum += (pair[1] - expected_error(pair[0]) )**2
     end
     sum
@@ -61,12 +63,12 @@ class Malge::ErrorFittedFunction
   end
 
   #Return the value of y[i] at which the most precise data is expected to be obtained.
-  def finest_y
+  def most_strict_pair
     raise NotImplementedError, "Define #{__method__}() in the inherited class."
 
     #In the most case, it would be sufficient to select belows.
-    @raw_pairs.max_by { |pair| pair[0] }[1]
-    @raw_pairs.min_by { |pair| pair[0] }[1]
+    @raw_pairs.max_by{ |pair| pair[0] }
+    @raw_pairs.mix_by{ |pair| pair[0] }
   end
 
   private
@@ -79,8 +81,5 @@ class Malge::ErrorFittedFunction
     raise NotImplementedError, "Define #{__method__}() in the inherited class."
   end
 
-  #Return the most precise y[i].
-  #This depends on each data and function.
-  #E.g., does a higher or lower value lead precise?
 end
 

data/lib/malge/errorfittedfunction/aexpbx.rb

@@ -5,6 +5,9 @@
 #
 #NOTE: @coefficients[0] might become negative value.
 # Need discussion for dealing?
+#
+#NOTE: Zero value for |y - y_last| is simply ignored due to impossible log evaluation.
+# 
 class Malge::ErrorFittedFunction::AExpBX < Malge::ErrorFittedFunction
 
   def fit
@@ -13,10 +16,15 @@ class Malge::ErrorFittedFunction::AExpBX < Malge::ErrorFittedFunction
       y = Math::log(pair[1])
       [x,y]
     }
+    inv_pairs.delete_if {|pair| ! pair[1].finite?} 
     @coefficients = Malge::LeastSquare.least_square_1st_degree(inv_pairs)
     @coefficients[0] = Math::exp @coefficients[0]
   end
 
+  def equation
+    sprintf("f(x) = %f \* exp(%f \* x)", * @coefficients)
+  end
+
   def expected_error(x)
     @coefficients[0] * Math::exp( @coefficients[1] * x)
   end
@@ -30,8 +38,8 @@ class Malge::ErrorFittedFunction::AExpBX < Malge::ErrorFittedFunction
     return Math::log( y / @coefficients[0])/@coefficients[1]
   end
 
-  def finest_y
-    @raw_pairs.max_by { |pair| pair[0] }[1]
+  def most_strict_pair
+    @raw_pairs.max_by{ |pair| pair[0] }
   end
 
 end

data/lib/malge/errorfittedfunction/aexpbx32.rb

@@ -1,7 +1,7 @@
 #! /usr/bin/env ruby
 # coding: utf-8
 
-#Assumed y = a[0] * exp(a[1] *x)
+#Assumed y = a[0] * exp(a[1] * (x ^{3/2}))
 #
 #NOTE: @coefficients[0] might become negative value.
 # Need discussion for dealing?
@@ -13,10 +13,15 @@ class Malge::ErrorFittedFunction::AExpBX32 < Malge::ErrorFittedFunction
       y = Math::log(pair[1])
       [x,y]
     }
+    inv_pairs.delete_if {|pair| ! pair[1].finite?} 
     @coefficients = Malge::LeastSquare.least_square_1st_degree(inv_pairs)
     @coefficients[0] = Math::exp @coefficients[0]
   end
 
+  def equation
+    sprintf("f(x) = %f \* exp(%f \* x^{3/2})", * @coefficients)
+  end
+
   def expected_error(x)
     @coefficients[0] * Math::exp( @coefficients[1] * x **(3.0/2.0))
   end
@@ -31,10 +36,11 @@ class Malge::ErrorFittedFunction::AExpBX32 < Malge::ErrorFittedFunction
     return (Math::log( y / @coefficients[0])/@coefficients[1]) **(2.0/3.0)
   end
 
-  def finest_y
-    @raw_pairs.max_by { |pair| pair[0] }[1]
+  def most_strict_pair
+    @raw_pairs.max_by{ |pair| pair[0] }
   end
 
+
 end
 
 

data/lib/malge/errorfittedfunction/axinv.rb

@@ -1,17 +1,21 @@
 #! /usr/bin/env ruby
 # coding: utf-8
 
-#Assumed y = a[0] + a[1]/x
+#Assumed y = a[0]/x
 #
-#NOTE: @coefficients[0] might become negative value.
-# Need discussion for dealing?
 class Malge::ErrorFittedFunction::AXInv < Malge::ErrorFittedFunction
 
   def fit
-    inv_pairs =  @diff_abs_pairs.map {|pair| [1.0/pair[0], pair[1]]}
+    inv_pairs = Marshal.load(Marshal.dump(@diff_abs_pairs))
+    #inv_pairs.delete([most_strict_x, 0.0])
+    inv_pairs.map! {|pair| [1.0/pair[0], pair[1]]}
     @coefficients = Malge::LeastSquare.least_square_proportional(inv_pairs)
   end
 
+  def equation
+    sprintf("f(x) = %f / x", * @coefficients)
+  end
+
   def expected_error(x)
     @coefficients[0] / x
   end
@@ -22,9 +26,10 @@ class Malge::ErrorFittedFunction::AXInv < Malge::ErrorFittedFunction
     return @coefficients[0] / y
   end
 
-  def finest_y
-    @raw_pairs.max_by { |pair| pair[0] }[1]
+  def most_strict_pair
+    @raw_pairs.max_by{ |pair| pair[0] }
   end
 
+
 end
 

data/lib/malge/errorfittedfunction/axinv2.rb

@@ -0,0 +1,33 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+#Assumed y = a[0] /(x^2)
+#
+class Malge::ErrorFittedFunction::AXInv2 < Malge::ErrorFittedFunction
+
+  def fit
+    inv_pairs =  @diff_abs_pairs.map {|pair| [1.0/(pair[0]**2), pair[1]]}
+    @coefficients = Malge::LeastSquare.least_square_proportional(inv_pairs)
+  end
+
+  def equation
+    sprintf("f(x) = %f / (x^2)", * @coefficients)
+  end
+
+  def expected_error(x)
+    @coefficients[0] / (x**2)
+  end
+
+  #y = a/x
+  #x = a/y
+  def x(y)
+    return Math::sqrt(@coefficients[0] / y)
+  end
+
+  def most_strict_pair
+    @raw_pairs.max_by{ |pair| pair[0] }
+  end
+
+
+end
+

data/lib/malge/errorfittedfunction/axinv3.rb

@@ -0,0 +1,33 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+#Assumed y = a[0]/(x^3)
+#
+class Malge::ErrorFittedFunction::AXInv3 < Malge::ErrorFittedFunction
+
+  def fit
+    inv_pairs =  @diff_abs_pairs.map {|pair| [1.0/(pair[0]**3), pair[1]]}
+    @coefficients = Malge::LeastSquare.least_square_proportional(inv_pairs)
+  end
+
+  def equation
+    sprintf("f(x) = %f / (x^3)", * @coefficients)
+  end
+
+  def expected_error(x)
+    @coefficients[0] / (x**3)
+  end
+
+  #y = a/x
+  #x = a/y
+  def x(y)
+    return (@coefficients[0] / y) ** (1.0/3.0)
+  end
+
+  def most_strict_pair
+    @raw_pairs.max_by{ |pair| pair[0] }
+  end
+
+
+end
+

data/lib/malge/errorfittedfunction/axinv32.rb

@@ -8,11 +8,14 @@
 class Malge::ErrorFittedFunction::AXInv32 < Malge::ErrorFittedFunction
 
   def fit
-    inv32_pairs =
-      @diff_abs_pairs.map {|pair| [1.0/(pair[0] ** (3.0/2.0)), pair[1]]}
+    inv32_pairs = @diff_abs_pairs.map {|pair| [pair[0] ** ( - 3.0/2.0), pair[1]]}
     @coefficients = Malge::LeastSquare.least_square_proportional(inv32_pairs)
   end
 
+  def equation
+    sprintf("f(x) = %f / (x^{3/2})", * @coefficients)
+  end
+
   def expected_error(x)
     @coefficients[0] /(x** (3.0/2.0))
   end
@@ -26,9 +29,10 @@ class Malge::ErrorFittedFunction::AXInv32 < Malge::ErrorFittedFunction
     return (@coefficients[0] / y ) ** (2.0/3.0)
   end
 
-  def finest_y
-    @raw_pairs.max_by { |pair| pair[0] }[1]
+  def most_strict_pair
+    @raw_pairs.max_by{ |pair| pair[0] }
   end
 
+
 end
 

data/lib/malge/leastsquare.rb

@@ -17,7 +17,6 @@ module Malge::LeastSquare
   #  ]
   #Note that not [a, b] in y = ax + b.
   def self.least_square_1st_degree(data_pairs)
-    #pp data_pairs
     a = 0.0 #x^2
     #b = 0.0 #y^2
     c = 0.0 #x^1
@@ -42,15 +41,12 @@ module Malge::LeastSquare
     a = 0.0 #x^2
     d = 0.0 #x*y
     n = data_pairs.size
-    #pp data_pairs
     data_pairs.each do |pairs|
       x = pairs[0].to_f
       y = pairs[1].to_f
       a += x**2
-      #b += y**2
       d += x*y
     end
-    #raise  if d == 0.0
     [d/a]
   end
 
@@ -64,8 +60,6 @@ module Malge::LeastSquare
   def self.variance_1st_degree(data_pairs)
     coefficients = self.least_square_1st_degree(data_pairs)
     data_pairs.inject(0.0) do |sum, pair|
-      #pp pair
-      #pp sum
       x = pair[0]
       y = pair[1]
       f_x = coefficients[0] + coefficients[1] * x

data/lib/malge/simultaneousequations.rb

@@ -26,7 +26,6 @@ class Malge::SimultaneousEquations
     n = matrix.column_size
     n.times do |i|
       tmp = Marshal.load( Marshal.dump( matrix ) )
-      #pp tmp
       n.times do |j|
         tmp[ j, i ] = values[ j ]
       end

data/malge.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "malge"
-  s.version = "0.0.6"
+  s.version = "0.0.7"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["ippei94da"]
-  s.date = "2013-02-16"
+  s.date = "2013-03-18"
   s.description = "Mathematical library to deal with basic problems in algebla.\n  "
   s.email = "ippei94da@gmail.com"
   s.extra_rdoc_files = [
@@ -29,9 +29,9 @@ Gem::Specification.new do |s|
     "lib/malge/errorfittedfunction/aexpbx.rb",
     "lib/malge/errorfittedfunction/aexpbx32.rb",
     "lib/malge/errorfittedfunction/axinv.rb",
+    "lib/malge/errorfittedfunction/axinv2.rb",
+    "lib/malge/errorfittedfunction/axinv3.rb",
     "lib/malge/errorfittedfunction/axinv32.rb",
-    "lib/malge/errorfittedfunction/axinv32plusb.rb",
-    "lib/malge/errorfittedfunction/axinvplusb.rb",
     "lib/malge/leastsquare.rb",
     "lib/malge/matrix.rb",
     "lib/malge/simultaneousequations.rb",
@@ -42,16 +42,16 @@ Gem::Specification.new do |s|
     "test/test_errorfittedfunction_aexpbx.rb",
     "test/test_errorfittedfunction_aexpbx32.rb",
     "test/test_errorfittedfunction_axinv.rb",
+    "test/test_errorfittedfunction_axinv2.rb",
+    "test/test_errorfittedfunction_axinv3.rb",
     "test/test_errorfittedfunction_axinv32.rb",
-    "test/test_errorfittedfunction_axinv32plusb.rb",
-    "test/test_errorfittedfunction_axinvplusb.rb",
     "test/test_leastsquare.rb",
     "test/test_simultaneousequations.rb"
   ]
   s.homepage = "http://github.com/ippei94da/malge"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.23"
+  s.rubygems_version = "1.8.11"
   s.summary = "Math ALGEbra library."
 
   if s.respond_to? :specification_version then
@@ -62,20 +62,17 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<bundler>, ["~> 1.2.2"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
       s.add_development_dependency(%q<simplecov>, [">= 0"])
-      s.add_development_dependency(%q<psych>, [">= 0"])
     else
       s.add_dependency(%q<rdoc>, ["~> 3.12"])
       s.add_dependency(%q<bundler>, ["~> 1.2.2"])
       s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
       s.add_dependency(%q<simplecov>, [">= 0"])
-      s.add_dependency(%q<psych>, [">= 0"])
     end
   else
     s.add_dependency(%q<rdoc>, ["~> 3.12"])
     s.add_dependency(%q<bundler>, ["~> 1.2.2"])
     s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
     s.add_dependency(%q<simplecov>, [">= 0"])
-    s.add_dependency(%q<psych>, [">= 0"])
   end
 end
 

data/test/test_errorfittedfunction.rb

@@ -1,15 +1,18 @@
 #! /usr/bin/env ruby
 # coding: utf-8
 
-require "test/unit"
-require "malge.rb"
-require "malge/errorfittedfunction.rb"
+require "helper"
+#require "test/unit"
+#require "malge.rb"
+#require "malge/errorfittedfunction.rb"
 
 class Malge::ErrorFittedFunction::Dummy00 < Malge::ErrorFittedFunction
   def fit; end
 end
 
 class Malge::ErrorFittedFunction::Dummy01 < Malge::ErrorFittedFunction
+  $tolerance = 1E-10
+
   def expected_error(x)
     @coefficients[0] + @coefficients[1] * x
   end
@@ -25,37 +28,61 @@ class Malge::ErrorFittedFunction::Dummy01 < Malge::ErrorFittedFunction
     @coefficients = [1.0, 2.0]
   end
 
-  def finest_y
-    #max
-    finest_pair = @raw_pairs.max_by { |pair| pair[0] }
-    finest_pair[1]
+  def most_strict_pair
+    @raw_pairs.max_by{ |pair| pair[0] }
+  end
+
+end
+
+## Dummy class to check Exception due to NaN.
+class Malge::ErrorFittedFunction::Dummy02 < Malge::ErrorFittedFunction
+  def expected_error(x)
+    @coefficients[0] + @coefficients[1] * x
+  end
+
+  #Assume: y = 1.0 + 2.0 * x
+  #x = 1/2( y - 1.0)
+  def x(y)
+    return 1.0/2.0 * (y - 1.0)
+  end
 
-    #@raw_pairs[x][1]
+  #Assume: y = 1.0 + 2.0 * x
+  def fit
+    @coefficients = [0.0/0.0, 1.0]
   end
 
+  def most_strict_pair
+    @raw_pairs.max_by { |pair| pair[0] }
+  end
 end
 
+
 class TC_ErrorFittedFunction < Test::Unit::TestCase
   def setup
-    #@eff00 = Malge::ErrorFittedFunction::Dummy00.new([], [])
     @eff01 = Malge::ErrorFittedFunction::Dummy01.new(
-      #2x+1 = 1, -1 
-      #2x+1 = 3, +2 
-      #2x+1 = 5, -1 
-      #[0.0, 1.0, 2.0],
-      #[0.0, 5.0, 4.0]
       [
         [0.0, 0.0],
         [1.0, 5.0],
         [2.0, 4.0],
       ]
     )
+
+    # not ordered.
+    data = [
+      [1000.0, -3.153327],
+      [1200.0, -3.150316],
+      [1500.0, -3.151397],
+      [ 500.0, -3.11294],
+      [ 600.0, -3.181593],
+      [ 700.0, -3.165176],
+      [ 900.0, -3.152733],
+      [ 500.0, -3.11294]
+    ]
+    @eff02 = Malge::ErrorFittedFunction::Dummy01.new(data)
   end
 
   def test_variance
-    assert_equal(13.0, @eff01.variance)
-    #diff_abs = [4,1]
-    #expected = [1,3]
+    assert_equal(38.0, @eff01.variance)
   end
 
   def test_expected_error
@@ -64,7 +91,47 @@ class TC_ErrorFittedFunction < Test::Unit::TestCase
     assert_equal(5.0, @eff01.expected_error(2.0))
   end
 
+  def test_equation
+    assert_raise(Malge::ErrorFittedFunction::NotImplementedError){
+      @eff01.equation
+    }
+  end
+
+  def test_initialize_diff_abs_pairs
+
+    assert_equal(1000.0, @eff02.diff_abs_pairs[0][0])
+    assert_equal(1200.0, @eff02.diff_abs_pairs[1][0])
+    assert_equal(1500.0, @eff02.diff_abs_pairs[2][0])
+    assert_equal( 500.0, @eff02.diff_abs_pairs[3][0])
+    assert_equal( 600.0, @eff02.diff_abs_pairs[4][0])
+    assert_equal( 700.0, @eff02.diff_abs_pairs[5][0])
+    assert_equal( 900.0, @eff02.diff_abs_pairs[6][0])
+    assert_equal( 500.0, @eff02.diff_abs_pairs[7][0])
+
+    assert_in_delta(0.001930, @eff02.diff_abs_pairs[0][1], $tolerance)
+    assert_in_delta(0.001081, @eff02.diff_abs_pairs[1][1], $tolerance)
+    assert_in_delta(0.0     , @eff02.diff_abs_pairs[2][1], $tolerance)
+    assert_in_delta(0.038457, @eff02.diff_abs_pairs[3][1], $tolerance)
+    assert_in_delta(0.030196, @eff02.diff_abs_pairs[4][1], $tolerance)
+    assert_in_delta(0.013779, @eff02.diff_abs_pairs[5][1], $tolerance)
+    assert_in_delta(0.001336, @eff02.diff_abs_pairs[6][1], $tolerance)
+    assert_in_delta(0.038457, @eff02.diff_abs_pairs[7][1], $tolerance)
+  end
+
+  def test_most_strict_pair
+    assert_equal(2.0, @eff01.most_strict_pair[0])
+    assert_equal(4.0, @eff01.most_strict_pair[1])
+
+    assert_equal(1500.0   , @eff02.most_strict_pair[0])
+    assert_equal(-3.151397, @eff02.most_strict_pair[1])
+  end
+
+
   def test_initialize
+    assert_raise(Malge::ErrorFittedFunction::NotImplementedError){
+      Malge::ErrorFittedFunction::Dummy00.new([[0.0, 1.0]])
+    }
+
     assert_raise(Malge::ErrorFittedFunction::NotImplementedError){
       Malge::ErrorFittedFunction.new([])
     }
@@ -77,10 +144,10 @@ class TC_ErrorFittedFunction < Test::Unit::TestCase
     assert_raise(Malge::ErrorFittedFunction::TypeError){
       Malge::ErrorFittedFunction.new([[1,2], 1])
     }
-  end
 
-  def test_finest_y
-    assert_equal(4.0, @eff01.finest_y)
+    assert_raise(Malge::ErrorFittedFunction::UnableCalculationError){
+      Malge::ErrorFittedFunction::Dummy02.new([[1,2]])
+    }
   end
 
 end