From 5f7f5098a64f7651d8e120b54f00f3b0be1ad66a Mon Sep 17 00:00:00 2001 From: mame Date: Wed, 27 Jan 2010 14:34:03 +0000 Subject: * test/matrix/test_matrix.rb, test/matrix/test_vector.rb: add some tests. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@26450 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- test/matrix/test_matrix.rb | 302 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 302 insertions(+) (limited to 'test/matrix/test_matrix.rb') diff --git a/test/matrix/test_matrix.rb b/test/matrix/test_matrix.rb index 6b9b587c6d..526d7a3124 100644 --- a/test/matrix/test_matrix.rb +++ b/test/matrix/test_matrix.rb @@ -10,6 +10,15 @@ class TestMatrix < Test::Unit::TestCase @n1 = Matrix[[2,3,4], [5,6,7]] end + def test_matrix + assert_equal(1, @m1[0, 0]) + assert_equal(2, @m1[0, 1]) + assert_equal(3, @m1[0, 2]) + assert_equal(4, @m1[1, 0]) + assert_equal(5, @m1[1, 1]) + assert_equal(6, @m1[1, 2]) + end + def test_identity assert_same @m1, @m1 assert_not_same @m1, @m2 @@ -153,4 +162,297 @@ class TestMatrix < Test::Unit::TestCase assert_equal(45, Matrix[[7,6], [3,9]].determinant) assert_equal(-18, Matrix[[2,0,1],[0,-2,2],[1,2,3]].determinant) end + + def test_new_matrix + assert_raise(TypeError) { Matrix[Object.new] } + o = Object.new + def o.to_ary; [1,2,3]; end + assert_equal(@m1, Matrix[o, [4,5,6]]) + end + + def test_rows + assert_equal(@m1, Matrix.rows([[1, 2, 3], [4, 5, 6]])) + end + + def test_columns + assert_equal(@m1, Matrix.columns([[1, 4], [2, 5], [3, 6]])) + end + + def test_diagonal + assert_equal(Matrix[[3,0,0],[0,2,0],[0,0,1]], Matrix.diagonal(3, 2, 1)) + assert_equal(Matrix[[4,0,0,0],[0,3,0,0],[0,0,2,0],[0,0,0,1]], Matrix.diagonal(4, 3, 2, 1)) + end + + def test_scalar + assert_equal(Matrix[[2,0,0],[0,2,0],[0,0,2]], Matrix.scalar(3, 2)) + assert_equal(Matrix[[2,0,0,0],[0,2,0,0],[0,0,2,0],[0,0,0,2]], Matrix.scalar(4, 2)) + end + + def test_identity2 + assert_equal(Matrix[[1,0,0],[0,1,0],[0,0,1]], Matrix.identity(3)) + assert_equal(Matrix[[1,0,0],[0,1,0],[0,0,1]], Matrix.unit(3)) + assert_equal(Matrix[[1,0,0],[0,1,0],[0,0,1]], Matrix.I(3)) + assert_equal(Matrix[[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]], Matrix.identity(4)) + end + + def test_zero + assert_equal(Matrix[[0,0,0],[0,0,0],[0,0,0]], Matrix.zero(3)) + assert_equal(Matrix[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]], Matrix.zero(4)) + assert_equal(Matrix[[0]], Matrix.zero(1)) + end + + def test_row_vector + assert_equal(Matrix[[1,2,3,4]], Matrix.row_vector([1,2,3,4])) + end + + def test_column_vector + assert_equal(Matrix[[1],[2],[3],[4]], Matrix.column_vector([1,2,3,4])) + end + + def test_empty + m = Matrix.empty(2, 0) + assert_equal(Matrix[ [], [] ], m) + n = Matrix.empty(0, 3) + assert_equal(Matrix.columns([ [], [], [] ]), n) + assert_equal(Matrix[[0, 0, 0], [0, 0, 0]], m * n) + end + + def test_row + assert_equal(Vector[1, 2, 3], @m1.row(0)) + assert_equal(Vector[4, 5, 6], @m1.row(1)) + a = []; @m1.row(0) {|x| a << x } + assert_equal([1, 2, 3], a) + end + + def test_column + assert_equal(Vector[1, 4], @m1.column(0)) + assert_equal(Vector[2, 5], @m1.column(1)) + assert_equal(Vector[3, 6], @m1.column(2)) + a = []; @m1.column(0) {|x| a << x } + assert_equal([1, 4], a) + end + + def test_collect + assert_equal(Matrix[[1, 4, 9], [16, 25, 36]], @m1.collect {|x| x ** 2 }) + end + + def test_minor + assert_equal(Matrix[[1, 2], [4, 5]], @m1.minor(0..1, 0..1)) + assert_equal(Matrix[[2], [5]], @m1.minor(0..1, 1..1)) + assert_equal(Matrix[[4, 5]], @m1.minor(1..1, 0..1)) + assert_equal(Matrix[[1, 2], [4, 5]], @m1.minor(0, 2, 0, 2)) + assert_equal(Matrix[[4, 5]], @m1.minor(1, 1, 0, 2)) + assert_equal(Matrix[[2], [5]], @m1.minor(0, 2, 1, 1)) + assert_raise(ArgumentError) { @m1.minor(0) } + end + + def test_regular? + assert(Matrix[[1, 0], [0, 1]].regular?) + assert(Matrix[[1, 0, 0], [0, 1, 0], [0, 0, 1]].regular?) + assert(!Matrix[[1, 0, 0], [0, 0, 1], [0, 0, 1]].regular?) + assert(!Matrix[[1, 0, 0], [0, 1, 0]].regular?) + end + + def test_singular? + assert(!Matrix[[1, 0], [0, 1]].singular?) + assert(!Matrix[[1, 0, 0], [0, 1, 0], [0, 0, 1]].singular?) + assert(Matrix[[1, 0, 0], [0, 0, 1], [0, 0, 1]].singular?) + assert(Matrix[[1, 0, 0], [0, 1, 0]].singular?) + end + + def test_square? + assert(Matrix[[1, 0], [0, 1]].square?) + assert(Matrix[[1, 0, 0], [0, 1, 0], [0, 0, 1]].square?) + assert(Matrix[[1, 0, 0], [0, 0, 1], [0, 0, 1]].square?) + assert(!Matrix[[1, 0, 0], [0, 1, 0]].square?) + end + + def test_compare_by_row_vectors + assert(@m1.compare_by_row_vectors([[1, 2, 3], [4, 5, 6]])) + end + + def test_mul + assert_equal(Matrix[[2,4],[6,8]], Matrix[[2,4],[6,8]] * Matrix.I(2)) + assert_equal(Matrix[[4,8],[12,16]], Matrix[[2,4],[6,8]] * 2) + assert_equal(Matrix[[4,8],[12,16]], 2 * Matrix[[2,4],[6,8]]) + assert_equal(Matrix[[14,32],[32,77]], @m1 * @m1.transpose) + assert_equal(Matrix[[17,22,27],[22,29,36],[27,36,45]], @m1.transpose * @m1) + assert_equal(Vector[14,32], @m1 * Vector[1,2,3]) + o = Object.new + def o.coerce(m) + [m, m.transpose] + end + assert_equal(Matrix[[14,32],[32,77]], @m1 * o) + end + + def test_add + assert_equal(Matrix[[6,0],[-4,12]], Matrix.scalar(2,5) + Matrix[[1,0],[-4,7]]) + assert_equal(Matrix[[3,5,7],[9,11,13]], @m1 + @n1) + assert_equal(Matrix[[3,5,7],[9,11,13]], @n1 + @m1) + assert_equal(Matrix[[2],[4],[6]], Matrix[[1],[2],[3]] + Vector[1,2,3]) + assert_raise(Matrix::ErrOperationNotDefined) { @m1 + 1 } + o = Object.new + def o.coerce(m) + [m, m] + end + assert_equal(Matrix[[2,4,6],[8,10,12]], @m1 + o) + end + + def test_sub + assert_equal(Matrix[[4,0],[4,-2]], Matrix.scalar(2,5) - Matrix[[1,0],[-4,7]]) + assert_equal(Matrix[[-1,-1,-1],[-1,-1,-1]], @m1 - @n1) + assert_equal(Matrix[[1,1,1],[1,1,1]], @n1 - @m1) + assert_equal(Matrix[[0],[0],[0]], Matrix[[1],[2],[3]] - Vector[1,2,3]) + assert_raise(Matrix::ErrOperationNotDefined) { @m1 - 1 } + o = Object.new + def o.coerce(m) + [m, m] + end + assert_equal(Matrix[[0,0,0],[0,0,0]], @m1 - o) + end + + def test_div + assert_equal(Matrix[[0,1,1],[2,2,3]], @m1 / 2) + assert_equal(Matrix[[1,1],[1,1]], Matrix[[2,2],[2,2]] / Matrix.scalar(2,2)) + o = Object.new + def o.coerce(m) + [m, Matrix.scalar(2,2)] + end + assert_equal(Matrix[[1,1],[1,1]], Matrix[[2,2],[2,2]] / o) + end + + def test_exp + assert_equal(Matrix[[67,96],[48,99]], Matrix[[7,6],[3,9]] ** 2) + assert_equal(Matrix.I(5), Matrix.I(5) ** -1) + assert_raise(Matrix::ErrOperationNotImplemented) { Matrix.I(5) ** 1.0 } + assert_raise(Matrix::ErrOperationNotDefined) { Matrix.I(5) ** Object.new } + end + + def test_det + assert_in_delta(45.0, Matrix[[7,6],[3,9]].det, 0.0001) + assert_in_delta(0.0, Matrix[[0,0],[0,0]].det, 0.0001) + assert_in_delta(-7.0, Matrix[[0,0,1],[0,7,6],[1,3,9]].det, 0.0001) + assert_in_delta(0,0, @m1.det, 0.0001) + end + + def test_det_e + assert_equal(45, Matrix[[7,6],[3,9]].det_e) + assert_equal(0, Matrix[[0,0],[0,0]].det_e) + assert_equal(-7, Matrix[[0,0,1],[0,7,6],[1,3,9]].det_e) + assert_equal(0, @m1.det_e) + end + + def test_rank2 + assert_equal(2, Matrix[[7,6],[3,9]].rank) + assert_equal(0, Matrix[[0,0],[0,0]].rank) + assert_equal(3, Matrix[[0,0,1],[0,7,6],[1,3,9]].rank) + assert_equal(2, @m1.rank) + end + + def test_rank_e + assert_equal(2, Matrix[[7,6],[3,9]].rank_e) + assert_equal(0, Matrix[[0,0],[0,0]].rank_e) + assert_equal(3, Matrix[[0,0,1],[0,7,6],[1,3,9]].rank_e) + assert_equal(2, @m1.rank_e) + end + + def test_trace + assert_equal(1+5+9, Matrix[[1,2,3],[4,5,6],[7,8,9]].trace) + end + + def test_transpose + assert_equal(Matrix[[1,4],[2,5],[3,6]], @m1.transpose) + end + + def test_row_vectors + assert_equal([Vector[1,2,3], Vector[4,5,6]], @m1.row_vectors) + end + + def test_column_vectors + assert_equal([Vector[1,4], Vector[2,5], Vector[3,6]], @m1.column_vectors) + end + + def test_elements_to_f + assert_equal(Matrix[[0.5,1.0,1.5],[2.0,2.5,3.0]], @m1.elements_to_f / 2) + end + + def test_elements_to_i + assert_equal(Matrix[[0,1,1],[2,2,3]], (@m1.elements_to_f / 2).elements_to_i) + end + + def test_elements_to_r + assert_equal(@m1.collect {|x| Rational(x, 2) }, @m1.elements_to_r / 2) + end + + def test_to_s + assert_equal("Matrix[[1, 2, 3], [4, 5, 6]]", @m1.to_s) + assert_equal("Matrix.empty(0, 0)", Matrix[].to_s) + assert_equal("Matrix.empty(1, 0)", Matrix[[]].to_s) + end + + def test_inspect + assert_equal("Matrix[[1, 2, 3], [4, 5, 6]]", @m1.inspect) + assert_equal("Matrix.empty(0, 0)", Matrix[].inspect) + assert_equal("Matrix.empty(1, 0)", Matrix[[]].inspect) + end + + def test_scalar_add + s1 = @m1.coerce(1).first + assert_equal(Matrix[[1]], (s1 + 0) * Matrix[[1]]) + assert_raise(Matrix::ErrOperationNotDefined) { s1 + Vector[0] } + assert_raise(Matrix::ErrOperationNotDefined) { s1 + Matrix[[0]] } + o = Object.new + def o.coerce(x) + [1, 1] + end + assert_equal(2, s1 + o) + end + + def test_scalar_sub + s1 = @m1.coerce(1).first + assert_equal(Matrix[[1]], (s1 - 0) * Matrix[[1]]) + assert_raise(Matrix::ErrOperationNotDefined) { s1 - Vector[0] } + assert_raise(Matrix::ErrOperationNotDefined) { s1 - Matrix[[0]] } + o = Object.new + def o.coerce(x) + [1, 1] + end + assert_equal(0, s1 - o) + end + + def test_scalar_mul + s1 = @m1.coerce(1).first + assert_equal(Matrix[[1]], (s1 * 1) * Matrix[[1]]) + assert_equal(Vector[2], s1 * Vector[2]) + assert_equal(Matrix[[2]], s1 * Matrix[[2]]) + o = Object.new + def o.coerce(x) + [1, 1] + end + assert_equal(1, s1 * o) + end + + def test_scalar_div + s1 = @m1.coerce(1).first + assert_equal(Matrix[[1]], (s1 / 1) * Matrix[[1]]) + assert_raise(Matrix::ErrOperationNotDefined) { s1 / Vector[0] } + assert_equal(Matrix[[Rational(1,2)]], s1 / Matrix[[2]]) + o = Object.new + def o.coerce(x) + [1, 1] + end + assert_equal(1, s1 / o) + end + + def test_scalar_pow + s1 = @m1.coerce(1).first + assert_equal(Matrix[[1]], (s1 ** 1) * Matrix[[1]]) + assert_raise(Matrix::ErrOperationNotDefined) { s1 ** Vector[0] } + assert_raise(Matrix::ErrOperationNotImplemented) { s1 ** Matrix[[1]] } + o = Object.new + def o.coerce(x) + [1, 1] + end + assert_equal(1, s1 ** o) + end end -- cgit v1.2.3