malge 0.0.8 → 0.0.9

data/test/test_errorfittedfunction_axinv32.rb

@@ -4,45 +4,47 @@
 require "helper"
 #require "test/unit"
 #require "malge.rb"
-##require "malge/errorfittedfunction.rb"
 
 class TC_ErrorFittedFunction_AXInv32 < Test::Unit::TestCase
+
   $tolerance = 1E-10
 
   def setup
     @axi3200 = Malge::ErrorFittedFunction::AXInv32.new(
       [
-        [1.0, 1.0],
-        [2.0, 3.0],
+        [(2.0 ** (-2.0/3.0)), 3.0],
+        [(2.0 ** ( 0      )), 1.0],
+        [(2.0 ** ( 2.0/3.0)), 1.0],
       ]
     )
   end
 
   def test_equation
-    assert_equal("f(x) = 1.777778 / (x^{3/2})", @axi3200.equation)
+    #assert_equal("1.777778 / (x**(3.0/2.0))", @axi3200.equation)
+    assert_equal("0.800000 / (x**(3.0/2.0))", @axi3200.equation)
   end
 
   def test_fit
-    assert_in_delta(16.0/9.0, @axi3200.coefficients[0], $tolerance)
+    assert_in_delta(0.8, @axi3200.coefficients[0], $tolerance)
   end
 
   def test_expected_error
-    assert_in_delta(16.0/9.0, @axi3200.expected_error(1.0), $tolerance)
-    assert_in_delta(16.0/9.0 * 2.0**(-3.0/2.0), @axi3200.expected_error(2.0), $tolerance)
-
+    assert_in_delta(0.8, @axi3200.expected_error(1.0), $tolerance)
+    assert_in_delta(0.8 * 2.0**(-3.0/2.0), @axi3200.expected_error(2.0), $tolerance)
   end
 
   def test_most_strict_pair
-    assert_in_delta(  2.0, @axi3200.most_strict_pair[0])
-    assert_in_delta(  3.0, @axi3200.most_strict_pair[1])
+    assert_in_delta((2.0 ** ( 2.0/3.0)), @axi3200.most_strict_pair[0])
+    assert_in_delta(1.0, @axi3200.most_strict_pair[1])
   end
 
   def test_variance
-    assert_equal(36.0/81.0, @axi3200.variance)
+    assert_equal(0.8, @axi3200.variance)
   end
 
   def test_x
-    assert_in_delta(1.0, @axi3200.x(16.0/9.0), $tolerance)
+    assert_in_delta((0.8 ** (2.0/3.0)), @axi3200.x(1.0), $tolerance)
   end
+
 end
 

data/test/test_errorfittedfunction_axinv4.rb

@@ -0,0 +1,50 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "helper"
+#require "test/unit"
+#require "malge.rb"
+
+class TC_ErrorFittedFunction_AXInv4 < Test::Unit::TestCase
+
+  $tolerance = 1E-10
+
+  def setup
+    @axi400 = Malge::ErrorFittedFunction::AXInv4.new(
+      [
+        [(2.0 ** (-1.0/4.0)), 3.0],
+        [(2.0 ** ( 0      )), 1.0],
+        [(2.0 ** ( 1.0/4.0)), 1.0],
+      ]
+    )
+  end
+
+
+  def test_equation
+    assert_equal("0.800000 / (x**4)", @axi400.equation)
+  end
+
+  def test_fit
+    assert_in_delta(0.8, @axi400.coefficients[0], $tolerance)
+  end
+
+  def test_expected_error
+    assert_in_delta(0.8        , @axi400.expected_error(1.0), $tolerance)
+    assert_in_delta((0.8        )/16.0, @axi400.expected_error(2.0), $tolerance)
+  end
+
+  def test_most_strict_pair
+    assert_in_delta( (2.0 ** ( 1.0/4.0)), @axi400.most_strict_pair[0])
+    assert_in_delta( 1.0, @axi400.most_strict_pair[1])
+  end
+
+  def test_variance
+    assert_in_delta( 0.8, @axi400.variance, $tolerance)
+  end
+
+  def test_x
+    assert_in_delta((0.8        )**(1.0/4.0), @axi400.x(1.0), $tolerance)
+  end
+
+end
+

data/test/test_leastsquare.rb

@@ -18,28 +18,28 @@ class TC_Malge < Test::Unit::TestCase
       [-10.000, -12.067],
       [ -9.000, -11.490],
       [ -8.000, -10.034],
-      [ -7.000,  -9.196],
-      [ -6.000,  -7.571],
-      [ -5.000,  -6.606],
-      [ -4.000,  -6.299],
-      [ -3.000,  -5.004],
-      [ -2.000,  -3.858],
-      [ -1.000,  -3.497],
-      [  0.000,  -2.484],
-      [  1.000,  -1.079],
-      [  2.000,  -0.425],
-      [  3.000,   0.915],
-      [  4.000,   2.031],
-      [  5.000,   3.438],
-      [  6.000,   4.012],
-      [  7.000,   5.258],
-      [  8.000,   5.695],
-      [  9.000,   6.645],
-      [ 10.000,   7.962],
+      [ -7.000,    -9.196],
+      [ -6.000,    -7.571],
+      [ -5.000,    -6.606],
+      [ -4.000,    -6.299],
+      [ -3.000,    -5.004],
+      [ -2.000,    -3.858],
+      [ -1.000,    -3.497],
+      [    0.000,  -2.484],
+      [    1.000,  -1.079],
+      [    2.000,  -0.425],
+      [    3.000,     0.915],
+      [    4.000,     2.031],
+      [    5.000,     3.438],
+      [    6.000,     4.012],
+      [    7.000,     5.258],
+      [    8.000,     5.695],
+      [    9.000,     6.645],
+      [ 10.000,       7.962],
     ]
     #should be below, confirmed by Excel.
     a0 = -2.0787619047619
-    a1 =  1.00077142857143
+    a1 =    1.00077142857143
 
     results=Malge::LeastSquare.least_square_1st_degree(data_pairs)
     assert_equal(2, results.size)
@@ -50,9 +50,9 @@ class TC_Malge < Test::Unit::TestCase
   def test_variance_1st_degree
     data_pairs = [
       [0.0, -1.0],
-      [1.0,  2.0],
-      [2.0,  3.0],
-      [3.0,  2.0],
+      [1.0,    2.0],
+      [2.0,    3.0],
+      [3.0,    2.0],
     ]
     assert_equal( 4.0, Malge::LeastSquare::variance_1st_degree(data_pairs))
   end
@@ -60,8 +60,8 @@ class TC_Malge < Test::Unit::TestCase
   def test_least_square_proportional
     data_pairs =
     [
-      [  1.000,  -2.000],
-      [  1.000,  -1.000],
+      [    1.000,  -2.000],
+      [    1.000,  -1.000],
     ]
     results = Malge::LeastSquare.least_square_proportional(data_pairs)
     assert_equal(1, results.size)
@@ -69,8 +69,8 @@ class TC_Malge < Test::Unit::TestCase
 
     data_pairs =
     [
-      [  1.000,  0.000],
-      [  2.000,  2.000],
+      [    1.000,  0.000],
+      [    2.000,  2.000],
     ]
     results = Malge::LeastSquare.least_square_proportional(data_pairs)
     assert_equal(1, results.size)
@@ -101,16 +101,16 @@ class TC_Malge < Test::Unit::TestCase
     assert_equal(corrects, Malge::LeastSquare.a_exp_bx(data_pairs))
 
     data_pairs = [
-      [0.0,  1.0],
-      [1.0,  1.0],
+      [0.0,    1.0],
+      [1.0,    1.0],
     ]
     assert_raise(Malge::LeastSquare::UnableCalculationError){
       Malge::LeastSquare.a_exp_bx(data_pairs)
     }
 
     data_pairs = [
-      [1.0,  1.0],
-      [1.0,  2.0],
+      [1.0,    1.0],
+      [1.0,    2.0],
     ]
     assert_raise(Malge::LeastSquare::UnableCalculationError){
       Malge::LeastSquare.a_exp_bx(data_pairs)
@@ -128,25 +128,25 @@ class TC_Malge < Test::Unit::TestCase
     #y = 4.0 exp^{- log_e 2 x}
     corrects = [ 4.0, - Math::log(2.0)]
     results = Malge::LeastSquare.least_square_a_exp_bx(data_pairs)
-    assert_equal(2          , results.size)
+    assert_equal(2                  , results.size)
     assert_in_delta(corrects[0], results[0], TOLERANCE)
     assert_in_delta(corrects[1], results[1], TOLERANCE)
 
     data_pairs = [
-      [0.0,  1.0],
-      [1.0,  4.0],
+      [0.0,    1.0],
+      [1.0,    4.0],
       [2.0, 16.0],
     ]
     corrects = [ 1.0, 2.0 * Math::log(2.0)]
     results = Malge::LeastSquare.least_square_a_exp_bx(data_pairs)
-    assert_equal(2          , results.size)
+    assert_equal(2                  , results.size)
     assert_in_delta(corrects[0], results[0], TOLERANCE)
     assert_in_delta(corrects[1], results[1], TOLERANCE)
 
     data_pairs = [
       [0.0, 16.0],
-      [1.0,  4.0],
-      [2.0,  0.0],
+      [1.0,    4.0],
+      [2.0,    0.0],
     ]
     assert_raise(Malge::LeastSquare::UnableCalculationError) do
       Malge::LeastSquare.least_square_a_exp_bx(data_pairs)

data/test/test_multivariablefunction.rb

@@ -0,0 +1,264 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "helper"
+require "pp"
+#require "test/unit"
+#require "pkg/klass.rb"
+
+
+class Malge::MultiVariableFunction
+ public :same?
+end
+
+class TC_MultiVariableFunction < Test::Unit::TestCase
+ def setup
+  @mvf00 = Malge::MultiVariableFunction.new(
+   [
+    {:a => 0.0, :b => 0.0, :c => 0.0, :z => 0.0 },
+    {:a => 0.0, :b => 0.0, :c => 1.0, :z => 1.0 },
+    {:a => 0.0, :b => 1.0, :c => 0.0, :z => 2.0 },
+    {:a => 0.0, :b => 1.0, :c => 1.0, :z => 3.0 },
+    {:a => 1.0, :b => 0.0, :c => 0.0, :z => 4.0 },
+    {:a => 1.0, :b => 0.0, :c => 1.0, :z => 5.0 },
+    {:a => 1.0, :b => 1.0, :c => 0.0, :z => 6.0 },
+    {:a => 1.0, :b => 1.0, :c => 1.0, :z => 7.0 },
+   ]
+  )
+ end
+
+ def test_abstract!
+  @mvf00.abstract!({:a => 0.0, :b => 0.0, :c => 0.0})
+  assert_equal(
+   [
+    {:a => 0.0, :b => 0.0, :c => 0.0, :z => 0.0 }
+   ],
+   @mvf00.data
+  )
+ end
+
+ def test_abstract
+  assert_equal(
+   [
+    {:a => 0.0, :b => 0.0, :c => 0.0, :z => 0.0 }
+   ],
+   @mvf00.abstract({:a => 0.0, :b => 0.0, :c => 0.0}).data
+  )
+  #check not destructive.
+  assert_equal(
+   [
+    {:a => 0.0, :b => 0.0, :c => 0.0, :z => 0.0 },
+    {:a => 0.0, :b => 0.0, :c => 1.0, :z => 1.0 },
+    {:a => 0.0, :b => 1.0, :c => 0.0, :z => 2.0 },
+    {:a => 0.0, :b => 1.0, :c => 1.0, :z => 3.0 },
+    {:a => 1.0, :b => 0.0, :c => 0.0, :z => 4.0 },
+    {:a => 1.0, :b => 0.0, :c => 1.0, :z => 5.0 },
+    {:a => 1.0, :b => 1.0, :c => 0.0, :z => 6.0 },
+    {:a => 1.0, :b => 1.0, :c => 1.0, :z => 7.0 },
+   ],
+   @mvf00.data
+  )
+
+  assert_equal(
+   [
+    {:a => 0.0, :b => 0.0, :c => 0.0, :z => 0.0 },
+    {:a => 0.0, :b => 0.0, :c => 1.0, :z => 1.0 },
+   ],
+   @mvf00.abstract({:a => 0.0, :b => 0.0}).data
+  )
+
+  assert_equal(
+   [
+    {:a => 0.0, :b => 0.0, :c => 0.0, :z => 0.0 },
+    {:a => 0.0, :b => 0.0, :c => 1.0, :z => 1.0 },
+    {:a => 0.0, :b => 1.0, :c => 0.0, :z => 2.0 },
+    {:a => 0.0, :b => 1.0, :c => 1.0, :z => 3.0 },
+   ],
+   @mvf00.abstract({:a => 0.0}).data
+  )
+
+  assert_equal(
+   [
+    {:a => 0.0, :b => 0.0, :c => 0.0, :z => 0.0 },
+    {:a => 0.0, :b => 0.0, :c => 1.0, :z => 1.0 },
+    {:a => 0.0, :b => 1.0, :c => 0.0, :z => 2.0 },
+    {:a => 0.0, :b => 1.0, :c => 1.0, :z => 3.0 },
+    {:a => 1.0, :b => 0.0, :c => 0.0, :z => 4.0 },
+    {:a => 1.0, :b => 0.0, :c => 1.0, :z => 5.0 },
+    {:a => 1.0, :b => 1.0, :c => 0.0, :z => 6.0 },
+    {:a => 1.0, :b => 1.0, :c => 1.0, :z => 7.0 },
+   ],
+   @mvf00.abstract({}).data
+  )
+
+  assert_equal( [], @mvf00.abstract({:a => 2.0}).data)
+ end
+
+ def test_unite_axes!
+  @mvf00.unite_axes!([:a, :b, :c])
+  assert_equal(
+   [
+    {:a => 0.0, :z => 0.0 },
+    {:a => 1.0, :z => 7.0 },
+   ],
+   @mvf00.data
+  )
+ end
+
+ def test_unite_axes
+  assert_equal(
+   [
+    {:a => 0.0, :z => 0.0 },
+    {:a => 1.0, :z => 7.0 },
+   ],
+   @mvf00.unite_axes([:a, :b, :c]).data
+  )
+  #check not destructive.
+  assert_equal(
+   [
+    {:a => 0.0, :b => 0.0, :c => 0.0, :z => 0.0 },
+    {:a => 0.0, :b => 0.0, :c => 1.0, :z => 1.0 },
+    {:a => 0.0, :b => 1.0, :c => 0.0, :z => 2.0 },
+    {:a => 0.0, :b => 1.0, :c => 1.0, :z => 3.0 },
+    {:a => 1.0, :b => 0.0, :c => 0.0, :z => 4.0 },
+    {:a => 1.0, :b => 0.0, :c => 1.0, :z => 5.0 },
+    {:a => 1.0, :b => 1.0, :c => 0.0, :z => 6.0 },
+    {:a => 1.0, :b => 1.0, :c => 1.0, :z => 7.0 },
+   ],
+   @mvf00.data
+  )
+
+  assert_equal(
+   [
+    {:ab => 0.0, :c => 0.0, :z => 0.0 },
+    {:ab => 0.0, :c => 1.0, :z => 1.0 },
+    {:ab => 1.0, :c => 0.0, :z => 6.0 },
+    {:ab => 1.0, :c => 1.0, :z => 7.0 },
+   ],
+   @mvf00.unite_axes([:a, :b], :ab).data
+  )
+
+  assert_equal(
+   [
+    {:a => 0.0, :c => 0.0, :z => 0.0 },
+    {:a => 0.0, :c => 1.0, :z => 1.0 },
+    {:a => 1.0, :c => 0.0, :z => 6.0 },
+    {:a => 1.0, :c => 1.0, :z => 7.0 },
+   ],
+   @mvf00.unite_axes([:a, :b]).data
+  )
+ end
+
+
+ def test_same?
+  assert_equal(
+   true,
+   @mvf00.same?({:a => 0.0, :b => 0.0, :c => 0.0, :z => 0.0 }, [:a, :b])
+  )
+
+  assert_equal(
+   true,
+   @mvf00.same?({:a => 0.0, :b => 0.0, :c => 1.0, :z => 1.0 }, [:a, :b])
+  )
+  assert_equal(
+   false,
+   @mvf00.same?({:a => 0.0, :b => 1.0, :c => 0.0, :z => 2.0 }, [:a, :b])
+  )
+  assert_equal(
+   false,
+   @mvf00.same?({:a => 0.0, :b => 1.0, :c => 1.0, :z => 3.0 }, [:a, :b])
+  )
+  assert_equal(
+   false,
+   @mvf00.same?({:a => 1.0, :b => 0.0, :c => 0.0, :z => 4.0 }, [:a, :b])
+  )
+  assert_equal(
+   false,
+   @mvf00.same?({:a => 1.0, :b => 0.0, :c => 1.0, :z => 5.0 }, [:a, :b])
+  )
+  assert_equal(
+   true,
+   @mvf00.same?({:a => 1.0, :b => 1.0, :c => 0.0, :z => 6.0 }, [:a, :b])
+  )
+  assert_equal(
+   true,
+   @mvf00.same?({:a => 1.0, :b => 1.0, :c => 1.0, :z => 7.0 }, [:a, :b])
+  )
+
+
+  # equal in float
+  assert_equal(
+   true,
+   @mvf00.same?({:a => 1E-15, :b => 0.0, :c => 0.0, :z => 0.0 }, [:a, :b])
+  )
+
+ end
+
+ def test_delete_axis!
+  @mvf00.delete_axis!(:a)
+  assert_equal(
+   [
+    {:b => 0.0, :c => 0.0, :z => 0.0 },
+    {:b => 0.0, :c => 1.0, :z => 1.0 },
+    {:b => 1.0, :c => 0.0, :z => 2.0 },
+    {:b => 1.0, :c => 1.0, :z => 3.0 },
+    {:b => 0.0, :c => 0.0, :z => 4.0 },
+    {:b => 0.0, :c => 1.0, :z => 5.0 },
+    {:b => 1.0, :c => 0.0, :z => 6.0 },
+    {:b => 1.0, :c => 1.0, :z => 7.0 },
+   ],
+   @mvf00.data
+  )
+ end
+
+ def test_delete_axis
+  result = @mvf00.delete_axis(:a)
+  assert_equal(
+   [
+    {:b => 0.0, :c => 0.0, :z => 0.0 },
+    {:b => 0.0, :c => 1.0, :z => 1.0 },
+    {:b => 1.0, :c => 0.0, :z => 2.0 },
+    {:b => 1.0, :c => 1.0, :z => 3.0 },
+    {:b => 0.0, :c => 0.0, :z => 4.0 },
+    {:b => 0.0, :c => 1.0, :z => 5.0 },
+    {:b => 1.0, :c => 0.0, :z => 6.0 },
+    {:b => 1.0, :c => 1.0, :z => 7.0 },
+   ],
+   result.data
+  )
+
+  assert_equal(
+   [
+    {:a => 0.0, :b => 0.0, :c => 0.0, :z => 0.0 },
+    {:a => 0.0, :b => 0.0, :c => 1.0, :z => 1.0 },
+    {:a => 0.0, :b => 1.0, :c => 0.0, :z => 2.0 },
+    {:a => 0.0, :b => 1.0, :c => 1.0, :z => 3.0 },
+    {:a => 1.0, :b => 0.0, :c => 0.0, :z => 4.0 },
+    {:a => 1.0, :b => 0.0, :c => 1.0, :z => 5.0 },
+    {:a => 1.0, :b => 1.0, :c => 0.0, :z => 6.0 },
+    {:a => 1.0, :b => 1.0, :c => 1.0, :z => 7.0 },
+   ],
+   @mvf00.data
+  )
+ end
+
+ def test_data_pairs
+  result = @mvf00.data_pairs(:a, :z)
+  assert_equal(
+   [
+    [0.0, 0.0 ],
+    [0.0, 1.0 ],
+    [0.0, 2.0 ],
+    [0.0, 3.0 ],
+    [1.0, 4.0 ],
+    [1.0, 5.0 ],
+    [1.0, 6.0 ],
+    [1.0, 7.0 ],
+   ],
+   result
+  )
+
+ end
+
+end
+