malge 0.0.8 → 0.0.9

data/lib/malge/simultaneousequations.rb

@@ -3,24 +3,39 @@ require "malge.rb"
 # Solve simultatneous equations with Cramer\'s formula.
 #
 # if you need to solve simultaneous equations,
-#   (a_11 ... a_1n) (x_1)   (c_1)
-#   (.... ... ....) (...) = (...)
-#   (a_n1 ... a_nn) (x_n)   (c_n)
+#       (a_11 ... a_1n) (x_1)       (c_1)
+#       (.... ... ....) (...) = (...)
+#       (a_n1 ... a_nn) (x_n)       (c_n)
 # command
 # % #{$0} a_11 ... a_1n ... a_n1 ... a_nn c_1 ... c_n
 # 
 
 # 連立1次方程式を表現するクラス。
 class Malge::SimultaneousEquations
+
+  class NotRegularError < Exception; end
+  class SizeMismatchError < Exception; end
+  class NotSquareError < Exception; end
+
   
   # Solve equation by Cramer's.
   # matrix は2重配列で与える。
   # 返されるのは、解の値を格納した配列。
   def self.cramer( matrix, values )
     matrix = Malge::Matrix.rows( matrix )
-    raise "Matrix is not squre: #{matrix.row_size} x #{matrix.column_size}." if ( ! matrix.square? )
-    raise "Matrix size (#{matrix.row_size}) and values size (#{values.size}) mismatched." if ( matrix.row_size != values.size )
-    raise "Matrix is not regular. Degree of freedom is #{matrix.column_size - matrix.rank}.\n" if ( ! matrix.regular? )
+    if ( ! matrix.square? )
+      str = "Matrix is not squre: #{matrix.row_size} x #{matrix.column_size}."
+      raise NotSquareError, str
+    end
+    if ( matrix.row_size != values.size )
+      str = "Matrix size (#{matrix.row_size}) and values size (#{values.size}) mismatched."
+      raise SizeMismatchError, str
+    end
+    if ( ! matrix.regular? )
+      str = "Matrix is not regular. Degree of freedom is #{matrix.column_size - matrix.rank}.\n"
+      str += matrix.to_s
+      raise NotRegularError, str
+    end
 
     results = Array.new
     n = matrix.column_size

data/test/analyzeerror/scatter.dat

@@ -0,0 +1,12 @@
+          ENCUT           TOTEN
+   500.00000000    -11.12271000
+   550.00000000    -11.14582400
+   600.00000000    -11.13928400
+   650.00000000    -11.13989200
+   700.00000000    -11.15230500
+   750.00000000    -11.14165100
+   800.00000000    -11.15094500
+   850.00000000    -11.15119000
+   900.00000000    -11.14783000
+   950.00000000    -11.14986900
+  1000.00000000    -11.15151900

data/test/helper.rb

@@ -1,11 +1,11 @@
 require 'rubygems'
 require 'bundler'
 begin
-  Bundler.setup(:default, :development)
+    Bundler.setup(:default, :development)
 rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
+    $stderr.puts e.message
+    $stderr.puts "Run `bundle install` to install missing gems"
+    exit e.status_code
 end
 require 'test/unit'
 

data/test/test_errorfittedfunction.rb

@@ -1,6 +1,7 @@
 #! /usr/bin/env ruby
 # coding: utf-8
 
+require "pp"
 require "helper"
 #require "test/unit"
 #require "malge.rb"
@@ -23,6 +24,10 @@ class Malge::ErrorFittedFunction::Dummy01 < Malge::ErrorFittedFunction
     return 1.0/2.0 * (y - 1.0)
   end
 
+  def equation
+   "x = 1/2( y - 1.0)"
+  end
+
   #Assume: y = 1.0 + 2.0 * x
   def fit
     @coefficients = [1.0, 2.0]
@@ -56,14 +61,38 @@ class Malge::ErrorFittedFunction::Dummy02 < Malge::ErrorFittedFunction
   end
 end
 
+class Malge::ErrorFittedFunction::Dummy03 < Malge::ErrorFittedFunction
+  $tolerance = 1E-10
+
+  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
+
+  #Assume: y = 1.0 + 2.0 * x
+  def fit
+    @coefficients = [1.0, 2.0]
+  end
+
+  def most_strict_pair
+    @raw_pairs.max_by{ |pair| pair[0] }
+  end
+
+end
+
 
 class TC_ErrorFittedFunction < Test::Unit::TestCase
   def setup
     @eff01 = Malge::ErrorFittedFunction::Dummy01.new(
       [
         [0.0, 0.0],
-        [1.0, 5.0],
         [2.0, 4.0],
+        [1.0, 5.0],
       ]
     )
 
@@ -82,7 +111,10 @@ class TC_ErrorFittedFunction < Test::Unit::TestCase
   end
 
   def test_variance
-    assert_equal(38.0, @eff01.variance)
+    # diff_abs_pairs = [[0.0, 4.0], [1.0, 1.0]
+    # function       = 2x + 1
+    # Then, 3 **2 + 2**2 = 13
+    assert_equal(13.0, @eff01.variance)
   end
 
   def test_expected_error
@@ -92,40 +124,49 @@ class TC_ErrorFittedFunction < Test::Unit::TestCase
   end
 
   def test_equation
+    eff = Malge::ErrorFittedFunction::Dummy03.new(
+      [
+        [0.0, 0.0],
+        [1.0, 5.0],
+        [2.0, 4.0],
+      ]
+    )
     assert_raise(Malge::ErrorFittedFunction::NotImplementedError){
-      @eff01.equation
+      eff.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)
+    assert_equal( 500.0, @eff02.diff_abs_pairs[0][0])
+    assert_equal( 500.0, @eff02.diff_abs_pairs[1][0])
+    assert_equal( 600.0, @eff02.diff_abs_pairs[2][0])
+    assert_equal( 700.0, @eff02.diff_abs_pairs[3][0])
+    assert_equal( 900.0, @eff02.diff_abs_pairs[4][0])
+    assert_equal(1000.0, @eff02.diff_abs_pairs[5][0])
+    assert_equal(1200.0, @eff02.diff_abs_pairs[6][0])
+
+    assert_in_delta(0.038457, @eff02.diff_abs_pairs[0][1], $tolerance)
+    assert_in_delta(0.038457, @eff02.diff_abs_pairs[1][1], $tolerance)
+    assert_in_delta(0.030196, @eff02.diff_abs_pairs[2][1], $tolerance)
+    assert_in_delta(0.013779, @eff02.diff_abs_pairs[3][1], $tolerance)
+    assert_in_delta(0.001336, @eff02.diff_abs_pairs[4][1], $tolerance)
+    assert_in_delta(0.001930, @eff02.diff_abs_pairs[5][1], $tolerance)
+    assert_in_delta(0.001081, @eff02.diff_abs_pairs[6][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(1500.0     , @eff02.most_strict_pair[0])
     assert_equal(-3.151397, @eff02.most_strict_pair[1])
   end
 
+  def test_count_equal_under_over
+    #pp @eff01
+    assert_equal([0, 1, 1], @eff01.count_equal_under_over)
+  end
 
   def test_initialize
     assert_raise(Malge::ErrorFittedFunction::NotImplementedError){
@@ -150,5 +191,21 @@ class TC_ErrorFittedFunction < Test::Unit::TestCase
     }
   end
 
+  def test_summary
+    io = StringIO.new
+    @eff01.summary(io)
+    io.rewind
+    #pp io.readlines
+    io.rewind
+    assert_equal(
+      ["Fitted function: x = 1/2( y - 1.0)\n",
+        "              x,           raw_y,   |diff_y_best|,  expected_error\n",
+        "   0.0000000000,    0.0000000000,    4.0000000000,    1.0000000000\n",
+        "   1.0000000000,    5.0000000000,    1.0000000000,    3.0000000000\n",
+        "   2.0000000000,    4.0000000000,    ------------,    5.0000000000\n"
+      ],
+      io.readlines
+    )
+  end
 end
 

data/test/test_errorfittedfunction_aexpbx.rb

@@ -38,7 +38,7 @@ class TC_ErrorFittedFunction_AExpBX < Test::Unit::TestCase
   #end
 
   def test_equation
-    assert_equal("f(x) = 4.000000 * exp(-0.693147 * x)", @aebx00.equation)
+    assert_equal("4.000000 * exp(-0.693147 * x)", @aebx00.equation)
   end
 
   def test_fit
@@ -63,12 +63,13 @@ class TC_ErrorFittedFunction_AExpBX < Test::Unit::TestCase
   end
 
   def test_most_strict
-    assert_in_delta(  3.0, @aebx00.most_strict_pair[0])
+    assert_in_delta(    3.0, @aebx00.most_strict_pair[0])
     assert_in_delta(100.0, @aebx00.most_strict_pair[1])
   end
 
   def test_variance
-    assert_in_delta( 0.25, @aebx00.variance, TOLERANCE)
+    assert_in_delta( 0.0, @aebx00.variance, TOLERANCE)
+    #assert_in_delta( 0.25, @aebx00.variance, TOLERANCE)
     #diff_abs = [4,1]
     #expected = [1,3]
   end

data/test/test_errorfittedfunction_aexpbx32.rb

@@ -15,19 +15,19 @@ class TC_ErrorFittedFunction_AExpBX32 < Test::Unit::TestCase
   def setup
     @aebx00 = Malge::ErrorFittedFunction::AExpBX32.new(
       [
-        [ 0.0, 100.0 + 3.0* 2.0**(-2.0 *  0    )],
-        [ 1.0, 100.0 + 3.0* 2.0**(-2.0 * 1.0  ) ],
+        [ 0.0, 100.0 + 3.0* 2.0**(-2.0 *    0        )],
+        [ 1.0, 100.0 + 3.0* 2.0**(-2.0 * 1.0    ) ],
         [ 2.0, 100.0 + 3.0* 2.0**(-2.0 * (2.0**(3.0/2.0)))],
-        [ 3.0, 100.0           ],
+        [ 3.0, 100.0                     ],
       ]
     )
 
     @aebx01 = Malge::ErrorFittedFunction::AExpBX32.new(
       [
-        [ 0.0, 100.0 + 3.0* 2.0**(-2.0 *  0    )],
-        [ 1.0, 100.0 - 3.0* 2.0**(-2.0 * 1.0  ) ],
+        [ 0.0, 100.0 + 3.0* 2.0**(-2.0 *    0        )],
+        [ 1.0, 100.0 - 3.0* 2.0**(-2.0 * 1.0    ) ],
         [ 2.0, 100.0 + 3.0* 2.0**(-2.0 * (2.0**(3.0/2.0)))],
-        [ 3.0, 100.0           ],
+        [ 3.0, 100.0                     ],
       ]
     )
   end
@@ -36,7 +36,7 @@ class TC_ErrorFittedFunction_AExpBX32 < Test::Unit::TestCase
   #end
 
   def test_equation
-    assert_equal("f(x) = 3.000000 * exp(-1.386294 * x^{3/2})", @aebx00.equation)
+    assert_equal("3.000000 * exp(-1.386294 * x**(3.0/2.0))", @aebx00.equation)
   end
 
 
@@ -78,12 +78,13 @@ class TC_ErrorFittedFunction_AExpBX32 < Test::Unit::TestCase
   end
 
   def test_most_strict_pair
-    assert_in_delta(  3.0, @aebx00.most_strict_pair[0])
+    assert_in_delta(    3.0, @aebx00.most_strict_pair[0])
     assert_in_delta(100.0, @aebx00.most_strict_pair[1])
   end
 
   def test_variance
-    correct = ( 3.0* 2.0**(-2.0 * (3.0**(3.0/2.0))))**2.0
+    #correct = (3.0* 2.0**(-2.0 * (3.0**(3.0/2.0))))**2.0
+    correct = 0.0
     assert_in_delta(correct, @aebx00.variance, TOLERANCE)
     assert_in_delta(correct, @aebx01.variance, TOLERANCE)
   end

data/test/test_errorfittedfunction_axinv.rb

@@ -4,7 +4,6 @@
 require "helper"
 #require "test/unit"
 #require "malge.rb"
-#require "malge/errorfittedfunction.rb"
 
 class TC_ErrorFittedFunction_AXInv < Test::Unit::TestCase
 
@@ -13,14 +12,15 @@ class TC_ErrorFittedFunction_AXInv < Test::Unit::TestCase
   def setup
     @axi00 = Malge::ErrorFittedFunction::AXInv.new(
       [
-        [1.0, 1.0],
         [0.5, 3.0],
+        [1.0, 1.0],
+        [2.0, 1.0],
       ]
     )
   end
 
   def test_equation
-    assert_equal("f(x) = 0.800000 / x", @axi00.equation)
+    assert_equal("0.800000 / x", @axi00.equation)
   end
 
   def test_fit
@@ -30,15 +30,14 @@ class TC_ErrorFittedFunction_AXInv < Test::Unit::TestCase
   def test_expected_error
     assert_in_delta(0.8, @axi00.expected_error(1.0), $tolerance)
     assert_in_delta(0.4, @axi00.expected_error(2.0), $tolerance)
-
   end
 
   def test_most_strict_pair
-    assert_in_delta(  1.0, @axi00.most_strict_pair[0])
-    assert_in_delta(  1.0, @axi00.most_strict_pair[1])
+    #pp @axi00.raw_pairs
+    assert_in_delta(    2.0, @axi00.most_strict_pair[0])
+    assert_in_delta(    1.0, @axi00.most_strict_pair[1])
   end
 
-
   def test_variance
     assert_equal( 0.8, @axi00.variance)
   end

data/test/test_errorfittedfunction_axinv2.rb

@@ -12,14 +12,15 @@ class TC_ErrorFittedFunction_AXInv2 < Test::Unit::TestCase
   def setup
     @axi200 = Malge::ErrorFittedFunction::AXInv2.new(
       [
-        [1.0,   1.0],
-        [2.0**(-1.0/2.0), 3.0],
+        [(2.0 ** (-1.0/2.0)), 3.0],
+        [(2.0 ** ( 0      )), 1.0],
+        [(2.0 ** ( 1.0/2.0)), 1.0],
       ]
     )
   end
 
   def test_equation
-    assert_equal("f(x) = 0.800000 / (x^2)", @axi200.equation)
+    assert_equal("0.800000 / (x**2)", @axi200.equation)
   end
 
   def test_fit
@@ -32,11 +33,10 @@ class TC_ErrorFittedFunction_AXInv2 < Test::Unit::TestCase
   end
 
   def test_most_strict_pair
-    assert_in_delta(  1.0, @axi200.most_strict_pair[0])
-    assert_in_delta(  1.0, @axi200.most_strict_pair[1])
+    assert_in_delta((2.0 ** ( 1.0/2.0)), @axi200.most_strict_pair[0])
+    assert_in_delta(    1.0, @axi200.most_strict_pair[1])
   end
 
-
   def test_variance
     assert_in_delta( 0.8, @axi200.variance, $tolerance)
   end
@@ -45,53 +45,5 @@ class TC_ErrorFittedFunction_AXInv2 < Test::Unit::TestCase
     assert_in_delta(1.0, @axi200.x(0.8), $tolerance)
   end
 
-
-  #def setup
-  #  @axi201 = Malge::ErrorFittedFunction::AXInv2.new(
-  #    [
-  #      [1.0, 20.0],
-  #      [2.0,  8.0],
-  #      [4.0,  5.0],
-  #      [8.0,  4.0],
-  #    ]
-  #  )
-  #end
-
-  ##def test_initialize
-  ##end
-
-  #def test_equation
-  #  assert_equal("f(x) = 16.000000 / (x^2)", @axi201.equation)
-  #end
-
-  #def test_fit
-  #  assert_equal([16.0], @axi201.coefficients)
-  #end
-
-  #def test_expected_error
-  #  assert_equal(16.0 , @axi201.expected_error(1.0))
-  #  assert_equal( 4.0 , @axi201.expected_error(2.0))
-  #  assert_equal( 1.0 , @axi201.expected_error(4.0))
-  #  assert_equal( 0.25, @axi201.expected_error(8.0))
-  #end
-
-  #def test_most_strict_y
-  #  assert_equal( 4.0, @axi201.most_strict_y)
-  #end
-
-  #def test_most_strict_x
-  #  assert_equal(8.0, @axi201.most_strict_x)
-  #end
-
-  #def test_variance
-  #  assert_equal( 0.0, @axi201.variance)
-  #  #diff_abs = [4,1]
-  #  #expected = [1,3]
-  #end
-
-  #def test_x
-  #  assert_equal(2.0, @axi201.x(4.0))
-  #end
-
 end
 

data/test/test_errorfittedfunction_axinv3.rb

@@ -6,19 +6,21 @@ require "helper"
 #require "malge.rb"
 
 class TC_ErrorFittedFunction_AXInv3 < Test::Unit::TestCase
+
   $tolerance = 1E-10
 
   def setup
     @axi300 = Malge::ErrorFittedFunction::AXInv3.new(
       [
-        [1.0,   1.0],
-        [2.0**(-1.0/3.0), 3.0],
+        [(2.0 ** (-1.0/3.0)), 3.0],
+        [(2.0 ** ( 0      )), 1.0],
+        [(2.0 ** ( 1.0/3.0)), 1.0],
       ]
     )
   end
 
   def test_equation
-    assert_equal("f(x) = 0.800000 / (x^3)", @axi300.equation)
+    assert_equal("0.800000 / (x**3)", @axi300.equation)
   end
 
   def test_fit
@@ -31,11 +33,10 @@ class TC_ErrorFittedFunction_AXInv3 < Test::Unit::TestCase
   end
 
   def test_most_strict_pair
-    assert_in_delta(  1.0, @axi300.most_strict_pair[0])
-    assert_in_delta(  1.0, @axi300.most_strict_pair[1])
+    assert_in_delta( (2.0 ** ( 1.0/3.0)), @axi300.most_strict_pair[0])
+    assert_in_delta( 1.0, @axi300.most_strict_pair[1])
   end
 
-
   def test_variance
     assert_in_delta( 0.8, @axi300.variance, $tolerance)
   end
@@ -44,52 +45,5 @@ class TC_ErrorFittedFunction_AXInv3 < Test::Unit::TestCase
     assert_in_delta(1.0, @axi300.x(0.8), $tolerance)
   end
 
-  #def setup
-  #  @axi301 = Malge::ErrorFittedFunction::AXInv3.new(
-  #    [
-  #      [1.0, 68.0],
-  #      [2.0, 12.0],
-  #      [4.0,  5.0],
-  #      [8.0,  4.0],
-  #    ]
-  #  )
-  #end
-
-  ##def test_initialize
-  ##end
-
-  #def test_equation
-  #  assert_equal("f(x) = 64.000000 / (x^3)", @axi301.equation)
-  #end
-
-  #def test_fit
-  #  assert_equal([64.0], @axi301.coefficients)
-  #end
-
-  #def test_expected_error
-  #  assert_equal(64.0  , @axi301.expected_error(1.0))
-  #  assert_equal( 8.0  , @axi301.expected_error(2.0))
-  #  assert_equal( 1.0  , @axi301.expected_error(4.0))
-  #  assert_equal( 0.125, @axi301.expected_error(8.0))
-  #end
-
-  #def test_most_strict_y
-  #  assert_equal( 4.0, @axi301.most_strict_y)
-  #end
-
-  #def test_most_strict_x
-  #  assert_equal(8.0, @axi301.most_strict_x)
-  #end
-
-  #def test_variance
-  #  assert_equal( 0.0, @axi301.variance)
-  #  #diff_abs = [4,1]
-  #  #expected = [1,3]
-  #end
-
-  #def test_x
-  #  assert_equal(2.0, @axi301.x(8.0))
-  #end
-
 end