[136] | 1 | // This file is part of Eigen, a lightweight C++ template library
|
---|
| 2 | // for linear algebra.
|
---|
| 3 | //
|
---|
| 4 | // Copyright (C) 2010 Benoit Jacob <jacob.benoit.1@gmail.com>
|
---|
| 5 | //
|
---|
| 6 | // This Source Code Form is subject to the terms of the Mozilla
|
---|
| 7 | // Public License v. 2.0. If a copy of the MPL was not distributed
|
---|
| 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
---|
| 9 |
|
---|
| 10 | #define EIGEN_NO_STATIC_ASSERT
|
---|
| 11 |
|
---|
| 12 | #include "main.h"
|
---|
| 13 |
|
---|
| 14 | #undef VERIFY_IS_APPROX
|
---|
| 15 | #define VERIFY_IS_APPROX(a, b) VERIFY((a)==(b));
|
---|
| 16 | #undef VERIFY_IS_NOT_APPROX
|
---|
| 17 | #define VERIFY_IS_NOT_APPROX(a, b) VERIFY((a)!=(b));
|
---|
| 18 |
|
---|
| 19 | template<typename MatrixType> void signed_integer_type_tests(const MatrixType& m)
|
---|
| 20 | {
|
---|
| 21 | typedef typename MatrixType::Index Index;
|
---|
| 22 | typedef typename MatrixType::Scalar Scalar;
|
---|
| 23 |
|
---|
| 24 | enum { is_signed = (Scalar(-1) > Scalar(0)) ? 0 : 1 };
|
---|
| 25 | VERIFY(is_signed == 1);
|
---|
| 26 |
|
---|
| 27 | Index rows = m.rows();
|
---|
| 28 | Index cols = m.cols();
|
---|
| 29 |
|
---|
| 30 | MatrixType m1(rows, cols),
|
---|
| 31 | m2 = MatrixType::Random(rows, cols),
|
---|
| 32 | mzero = MatrixType::Zero(rows, cols);
|
---|
| 33 |
|
---|
| 34 | do {
|
---|
| 35 | m1 = MatrixType::Random(rows, cols);
|
---|
| 36 | } while(m1 == mzero || m1 == m2);
|
---|
| 37 |
|
---|
| 38 | // check linear structure
|
---|
| 39 |
|
---|
| 40 | Scalar s1;
|
---|
| 41 | do {
|
---|
| 42 | s1 = internal::random<Scalar>();
|
---|
| 43 | } while(s1 == 0);
|
---|
| 44 |
|
---|
| 45 | VERIFY_IS_EQUAL(-(-m1), m1);
|
---|
| 46 | VERIFY_IS_EQUAL(-m2+m1+m2, m1);
|
---|
| 47 | VERIFY_IS_EQUAL((-m1+m2)*s1, -s1*m1+s1*m2);
|
---|
| 48 | }
|
---|
| 49 |
|
---|
| 50 | template<typename MatrixType> void integer_type_tests(const MatrixType& m)
|
---|
| 51 | {
|
---|
| 52 | typedef typename MatrixType::Index Index;
|
---|
| 53 | typedef typename MatrixType::Scalar Scalar;
|
---|
| 54 |
|
---|
| 55 | VERIFY(NumTraits<Scalar>::IsInteger);
|
---|
| 56 | enum { is_signed = (Scalar(-1) > Scalar(0)) ? 0 : 1 };
|
---|
| 57 | VERIFY(int(NumTraits<Scalar>::IsSigned) == is_signed);
|
---|
| 58 |
|
---|
| 59 | typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
|
---|
| 60 |
|
---|
| 61 | Index rows = m.rows();
|
---|
| 62 | Index cols = m.cols();
|
---|
| 63 |
|
---|
| 64 | // this test relies a lot on Random.h, and there's not much more that we can do
|
---|
| 65 | // to test it, hence I consider that we will have tested Random.h
|
---|
| 66 | MatrixType m1(rows, cols),
|
---|
| 67 | m2 = MatrixType::Random(rows, cols),
|
---|
| 68 | m3(rows, cols),
|
---|
| 69 | mzero = MatrixType::Zero(rows, cols);
|
---|
| 70 |
|
---|
| 71 | typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> SquareMatrixType;
|
---|
| 72 | SquareMatrixType identity = SquareMatrixType::Identity(rows, rows),
|
---|
| 73 | square = SquareMatrixType::Random(rows, rows);
|
---|
| 74 | VectorType v1(rows),
|
---|
| 75 | v2 = VectorType::Random(rows),
|
---|
| 76 | vzero = VectorType::Zero(rows);
|
---|
| 77 |
|
---|
| 78 | do {
|
---|
| 79 | m1 = MatrixType::Random(rows, cols);
|
---|
| 80 | } while(m1 == mzero || m1 == m2);
|
---|
| 81 |
|
---|
| 82 | do {
|
---|
| 83 | v1 = VectorType::Random(rows);
|
---|
| 84 | } while(v1 == vzero || v1 == v2);
|
---|
| 85 |
|
---|
| 86 | VERIFY_IS_APPROX( v1, v1);
|
---|
| 87 | VERIFY_IS_NOT_APPROX( v1, 2*v1);
|
---|
| 88 | VERIFY_IS_APPROX( vzero, v1-v1);
|
---|
| 89 | VERIFY_IS_APPROX( m1, m1);
|
---|
| 90 | VERIFY_IS_NOT_APPROX( m1, 2*m1);
|
---|
| 91 | VERIFY_IS_APPROX( mzero, m1-m1);
|
---|
| 92 |
|
---|
| 93 | VERIFY_IS_APPROX(m3 = m1,m1);
|
---|
| 94 | MatrixType m4;
|
---|
| 95 | VERIFY_IS_APPROX(m4 = m1,m1);
|
---|
| 96 |
|
---|
| 97 | m3.real() = m1.real();
|
---|
| 98 | VERIFY_IS_APPROX(static_cast<const MatrixType&>(m3).real(), static_cast<const MatrixType&>(m1).real());
|
---|
| 99 | VERIFY_IS_APPROX(static_cast<const MatrixType&>(m3).real(), m1.real());
|
---|
| 100 |
|
---|
| 101 | // check == / != operators
|
---|
| 102 | VERIFY(m1==m1);
|
---|
| 103 | VERIFY(m1!=m2);
|
---|
| 104 | VERIFY(!(m1==m2));
|
---|
| 105 | VERIFY(!(m1!=m1));
|
---|
| 106 | m1 = m2;
|
---|
| 107 | VERIFY(m1==m2);
|
---|
| 108 | VERIFY(!(m1!=m2));
|
---|
| 109 |
|
---|
| 110 | // check linear structure
|
---|
| 111 |
|
---|
| 112 | Scalar s1;
|
---|
| 113 | do {
|
---|
| 114 | s1 = internal::random<Scalar>();
|
---|
| 115 | } while(s1 == 0);
|
---|
| 116 |
|
---|
| 117 | VERIFY_IS_EQUAL(m1+m1, 2*m1);
|
---|
| 118 | VERIFY_IS_EQUAL(m1+m2-m1, m2);
|
---|
| 119 | VERIFY_IS_EQUAL(m1*s1, s1*m1);
|
---|
| 120 | VERIFY_IS_EQUAL((m1+m2)*s1, s1*m1+s1*m2);
|
---|
| 121 | m3 = m2; m3 += m1;
|
---|
| 122 | VERIFY_IS_EQUAL(m3, m1+m2);
|
---|
| 123 | m3 = m2; m3 -= m1;
|
---|
| 124 | VERIFY_IS_EQUAL(m3, m2-m1);
|
---|
| 125 | m3 = m2; m3 *= s1;
|
---|
| 126 | VERIFY_IS_EQUAL(m3, s1*m2);
|
---|
| 127 |
|
---|
| 128 | // check matrix product.
|
---|
| 129 |
|
---|
| 130 | VERIFY_IS_APPROX(identity * m1, m1);
|
---|
| 131 | VERIFY_IS_APPROX(square * (m1 + m2), square * m1 + square * m2);
|
---|
| 132 | VERIFY_IS_APPROX((m1 + m2).transpose() * square, m1.transpose() * square + m2.transpose() * square);
|
---|
| 133 | VERIFY_IS_APPROX((m1 * m2.transpose()) * m1, m1 * (m2.transpose() * m1));
|
---|
| 134 | }
|
---|
| 135 |
|
---|
| 136 | void test_integer_types()
|
---|
| 137 | {
|
---|
| 138 | for(int i = 0; i < g_repeat; i++) {
|
---|
| 139 | CALL_SUBTEST_1( integer_type_tests(Matrix<unsigned int, 1, 1>()) );
|
---|
| 140 | CALL_SUBTEST_1( integer_type_tests(Matrix<unsigned long, 3, 4>()) );
|
---|
| 141 |
|
---|
| 142 | CALL_SUBTEST_2( integer_type_tests(Matrix<long, 2, 2>()) );
|
---|
| 143 | CALL_SUBTEST_2( signed_integer_type_tests(Matrix<long, 2, 2>()) );
|
---|
| 144 |
|
---|
| 145 | CALL_SUBTEST_3( integer_type_tests(Matrix<char, 2, Dynamic>(2, 10)) );
|
---|
| 146 | CALL_SUBTEST_3( signed_integer_type_tests(Matrix<signed char, 2, Dynamic>(2, 10)) );
|
---|
| 147 |
|
---|
| 148 | CALL_SUBTEST_4( integer_type_tests(Matrix<unsigned char, 3, 3>()) );
|
---|
| 149 | CALL_SUBTEST_4( integer_type_tests(Matrix<unsigned char, Dynamic, Dynamic>(20, 20)) );
|
---|
| 150 |
|
---|
| 151 | CALL_SUBTEST_5( integer_type_tests(Matrix<short, Dynamic, 4>(7, 4)) );
|
---|
| 152 | CALL_SUBTEST_5( signed_integer_type_tests(Matrix<short, Dynamic, 4>(7, 4)) );
|
---|
| 153 |
|
---|
| 154 | CALL_SUBTEST_6( integer_type_tests(Matrix<unsigned short, 4, 4>()) );
|
---|
| 155 |
|
---|
| 156 | CALL_SUBTEST_7( integer_type_tests(Matrix<long long, 11, 13>()) );
|
---|
| 157 | CALL_SUBTEST_7( signed_integer_type_tests(Matrix<long long, 11, 13>()) );
|
---|
| 158 |
|
---|
| 159 | CALL_SUBTEST_8( integer_type_tests(Matrix<unsigned long long, Dynamic, 5>(1, 5)) );
|
---|
| 160 | }
|
---|
| 161 | }
|
---|