1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2009 Hauke Heibel <hauke.heibel@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 #include "main.h"
11
12 #include <Eigen/Core>
13
14 using namespace Eigen;
15
16 template <typename Scalar, int Storage>
run_matrix_tests()17 void run_matrix_tests()
18 {
19 typedef Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Storage> MatrixType;
20 typedef typename MatrixType::Index Index;
21
22 MatrixType m, n;
23
24 // boundary cases ...
25 m = n = MatrixType::Random(50,50);
26 m.conservativeResize(1,50);
27 VERIFY_IS_APPROX(m, n.block(0,0,1,50));
28
29 m = n = MatrixType::Random(50,50);
30 m.conservativeResize(50,1);
31 VERIFY_IS_APPROX(m, n.block(0,0,50,1));
32
33 m = n = MatrixType::Random(50,50);
34 m.conservativeResize(50,50);
35 VERIFY_IS_APPROX(m, n.block(0,0,50,50));
36
37 // random shrinking ...
38 for (int i=0; i<25; ++i)
39 {
40 const Index rows = internal::random<Index>(1,50);
41 const Index cols = internal::random<Index>(1,50);
42 m = n = MatrixType::Random(50,50);
43 m.conservativeResize(rows,cols);
44 VERIFY_IS_APPROX(m, n.block(0,0,rows,cols));
45 }
46
47 // random growing with zeroing ...
48 for (int i=0; i<25; ++i)
49 {
50 const Index rows = internal::random<Index>(50,75);
51 const Index cols = internal::random<Index>(50,75);
52 m = n = MatrixType::Random(50,50);
53 m.conservativeResizeLike(MatrixType::Zero(rows,cols));
54 VERIFY_IS_APPROX(m.block(0,0,n.rows(),n.cols()), n);
55 VERIFY( rows<=50 || m.block(50,0,rows-50,cols).sum() == Scalar(0) );
56 VERIFY( cols<=50 || m.block(0,50,rows,cols-50).sum() == Scalar(0) );
57 }
58 }
59
60 template <typename Scalar>
run_vector_tests()61 void run_vector_tests()
62 {
63 typedef Matrix<Scalar, 1, Eigen::Dynamic> VectorType;
64
65 VectorType m, n;
66
67 // boundary cases ...
68 m = n = VectorType::Random(50);
69 m.conservativeResize(1);
70 VERIFY_IS_APPROX(m, n.segment(0,1));
71
72 m = n = VectorType::Random(50);
73 m.conservativeResize(50);
74 VERIFY_IS_APPROX(m, n.segment(0,50));
75
76 m = n = VectorType::Random(50);
77 m.conservativeResize(m.rows(),1);
78 VERIFY_IS_APPROX(m, n.segment(0,1));
79
80 m = n = VectorType::Random(50);
81 m.conservativeResize(m.rows(),50);
82 VERIFY_IS_APPROX(m, n.segment(0,50));
83
84 // random shrinking ...
85 for (int i=0; i<50; ++i)
86 {
87 const int size = internal::random<int>(1,50);
88 m = n = VectorType::Random(50);
89 m.conservativeResize(size);
90 VERIFY_IS_APPROX(m, n.segment(0,size));
91
92 m = n = VectorType::Random(50);
93 m.conservativeResize(m.rows(), size);
94 VERIFY_IS_APPROX(m, n.segment(0,size));
95 }
96
97 // random growing with zeroing ...
98 for (int i=0; i<50; ++i)
99 {
100 const int size = internal::random<int>(50,100);
101 m = n = VectorType::Random(50);
102 m.conservativeResizeLike(VectorType::Zero(size));
103 VERIFY_IS_APPROX(m.segment(0,50), n);
104 VERIFY( size<=50 || m.segment(50,size-50).sum() == Scalar(0) );
105
106 m = n = VectorType::Random(50);
107 m.conservativeResizeLike(Matrix<Scalar,Dynamic,Dynamic>::Zero(1,size));
108 VERIFY_IS_APPROX(m.segment(0,50), n);
109 VERIFY( size<=50 || m.segment(50,size-50).sum() == Scalar(0) );
110 }
111 }
112
test_conservative_resize()113 void test_conservative_resize()
114 {
115 for(int i=0; i<g_repeat; ++i)
116 {
117 CALL_SUBTEST_1((run_matrix_tests<int, Eigen::RowMajor>()));
118 CALL_SUBTEST_1((run_matrix_tests<int, Eigen::ColMajor>()));
119 CALL_SUBTEST_2((run_matrix_tests<float, Eigen::RowMajor>()));
120 CALL_SUBTEST_2((run_matrix_tests<float, Eigen::ColMajor>()));
121 CALL_SUBTEST_3((run_matrix_tests<double, Eigen::RowMajor>()));
122 CALL_SUBTEST_3((run_matrix_tests<double, Eigen::ColMajor>()));
123 CALL_SUBTEST_4((run_matrix_tests<std::complex<float>, Eigen::RowMajor>()));
124 CALL_SUBTEST_4((run_matrix_tests<std::complex<float>, Eigen::ColMajor>()));
125 CALL_SUBTEST_5((run_matrix_tests<std::complex<double>, Eigen::RowMajor>()));
126 CALL_SUBTEST_6((run_matrix_tests<std::complex<double>, Eigen::ColMajor>()));
127
128 CALL_SUBTEST_1((run_vector_tests<int>()));
129 CALL_SUBTEST_2((run_vector_tests<float>()));
130 CALL_SUBTEST_3((run_vector_tests<double>()));
131 CALL_SUBTEST_4((run_vector_tests<std::complex<float> >()));
132 CALL_SUBTEST_5((run_vector_tests<std::complex<double> >()));
133 }
134 }
135