Main MRPT website > C++ reference for MRPT 1.9.9
matrix_ops4_unittest.cpp
Go to the documentation of this file.
1 /* +------------------------------------------------------------------------+
2  | Mobile Robot Programming Toolkit (MRPT) |
3  | http://www.mrpt.org/ |
4  | |
5  | Copyright (c) 2005-2017, Individual contributors, see AUTHORS file |
6  | See: http://www.mrpt.org/Authors - All rights reserved. |
7  | Released under BSD License. See details in http://www.mrpt.org/License |
8  +------------------------------------------------------------------------+ */
9 
10 // Note: Matrices unit tests have been split in different files since
11 // building them with eigen3 eats a lot of RAM and may be a problem while
12 // compiling in small systems.
13 
14 #include <mrpt/math/CMatrixFixedNumeric.h>
15 #include <mrpt/utils/metaprogramming.h>
16 #include <mrpt/utils/CMemoryStream.h>
17 #include <mrpt/random.h>
18 #include <gtest/gtest.h>
19 #include <numeric> // std::accumulate()
20 
21 using namespace mrpt;
22 using namespace mrpt::utils;
23 using namespace mrpt::math;
24 using namespace mrpt::random;
25 using namespace mrpt::utils::metaprogramming;
26 using namespace std;
27 
28 TEST(Matrices, meanAndStd)
29 {
30  /* meanAndStd: Computes a row with the mean values of each column in the
31  matrix and
32  the associated vector with the standard deviation of each column. */
33 
34  const double dat_A[] = {
35  2.8955668335, 2.3041932983, 1.9002381085, 1.7993158652, 1.8456197228,
36  2.9632296740, 1.9368565578, 2.1988923358, 2.0547605617, 2.5655678993,
37  2.3041932983, 3.8406914364, 2.1811218706, 3.2312564555, 2.4736403918,
38  3.4703311380, 1.4874417483, 3.1073538218, 2.1353324397, 2.9541115932,
39  1.9002381085, 2.1811218706, 2.4942067597, 1.6851007198, 1.4585872052,
40  2.3015952197, 1.0955231591, 2.2979627790, 1.3918738834, 2.1854562572,
41  1.7993158652, 3.2312564555, 1.6851007198, 3.1226161015, 1.6779632687,
42  2.7195826381, 1.2397348013, 2.3757864319, 1.6291224768, 2.4463194915,
43  1.8456197228, 2.4736403918, 1.4585872052, 1.6779632687, 2.8123267839,
44  2.5860688816, 1.4131630919, 2.1914803135, 1.5542420639, 2.7170092067,
45  2.9632296740, 3.4703311380, 2.3015952197, 2.7195826381, 2.5860688816,
46  4.1669180394, 2.1145239023, 3.3214801332, 2.6694845663, 3.0742063088,
47  1.9368565578, 1.4874417483, 1.0955231591, 1.2397348013, 1.4131630919,
48  2.1145239023, 1.8928811570, 1.7097998455, 1.7205860530, 1.8710847505,
49  2.1988923358, 3.1073538218, 2.2979627790, 2.3757864319, 2.1914803135,
50  3.3214801332, 1.7097998455, 3.4592638415, 2.1518695071, 2.8907499694,
51  2.0547605617, 2.1353324397, 1.3918738834, 1.6291224768, 1.5542420639,
52  2.6694845663, 1.7205860530, 2.1518695071, 2.1110960664, 1.6731209980,
53  2.5655678993, 2.9541115932, 2.1854562572, 2.4463194915, 2.7170092067,
54  3.0742063088, 1.8710847505, 2.8907499694, 1.6731209980, 3.9093678727};
55  CMatrixFixedNumeric<double, 10, 10> A(dat_A);
56 
57  // Compute mean & std of each column:
58  CVectorDouble result_mean, result_std;
59  A.meanAndStd(result_mean, result_std);
60 
61  // Result from MATLAB:
62  const double dat_good_M[] = {
63  2.246424086, 2.718547419, 1.899166596, 2.192679825, 2.073010093,
64  2.938742050, 1.648159507, 2.570463898, 1.909148862, 2.628699435};
65  const Eigen::Matrix<double, 10, 1> good_M(dat_good_M);
66  const double dat_good_S[] = {
67  0.428901371, 0.720352792, 0.468999497, 0.684910097, 0.546595053,
68  0.604303301, 0.328759015, 0.582584159, 0.382009344, 0.644788760};
69  const Eigen::Matrix<double, 10, 1> good_S(dat_good_S);
70 
71  EXPECT_NEAR((result_mean - good_M).array().abs().sum(), 0, 1e-4);
72  EXPECT_NEAR((result_std - good_S).array().abs().sum(), 0, 1e-4);
73 }
74 
75 TEST(Matrices, meanAndStdAll)
76 {
77  /* meanAndStd: Computes a row with the mean values of each column in the
78  matrix and
79  the associated vector with the standard deviation of each column. */
80 
81  const double dat_A[] = {
82  2.8955668335, 2.3041932983, 1.9002381085, 1.7993158652, 1.8456197228,
83  2.9632296740, 1.9368565578, 2.1988923358, 2.0547605617, 2.5655678993,
84  2.3041932983, 3.8406914364, 2.1811218706, 3.2312564555, 2.4736403918,
85  3.4703311380, 1.4874417483, 3.1073538218, 2.1353324397, 2.9541115932,
86  1.9002381085, 2.1811218706, 2.4942067597, 1.6851007198, 1.4585872052,
87  2.3015952197, 1.0955231591, 2.2979627790, 1.3918738834, 2.1854562572,
88  1.7993158652, 3.2312564555, 1.6851007198, 3.1226161015, 1.6779632687,
89  2.7195826381, 1.2397348013, 2.3757864319, 1.6291224768, 2.4463194915,
90  1.8456197228, 2.4736403918, 1.4585872052, 1.6779632687, 2.8123267839,
91  2.5860688816, 1.4131630919, 2.1914803135, 1.5542420639, 2.7170092067,
92  2.9632296740, 3.4703311380, 2.3015952197, 2.7195826381, 2.5860688816,
93  4.1669180394, 2.1145239023, 3.3214801332, 2.6694845663, 3.0742063088,
94  1.9368565578, 1.4874417483, 1.0955231591, 1.2397348013, 1.4131630919,
95  2.1145239023, 1.8928811570, 1.7097998455, 1.7205860530, 1.8710847505,
96  2.1988923358, 3.1073538218, 2.2979627790, 2.3757864319, 2.1914803135,
97  3.3214801332, 1.7097998455, 3.4592638415, 2.1518695071, 2.8907499694,
98  2.0547605617, 2.1353324397, 1.3918738834, 1.6291224768, 1.5542420639,
99  2.6694845663, 1.7205860530, 2.1518695071, 2.1110960664, 1.6731209980,
100  2.5655678993, 2.9541115932, 2.1854562572, 2.4463194915, 2.7170092067,
101  3.0742063088, 1.8710847505, 2.8907499694, 1.6731209980, 3.9093678727};
102  CMatrixFixedNumeric<double, 10, 10> A(dat_A);
103 
104  // Compute mean & std of each column:
105  double result_mean, result_std;
106  A.meanAndStdAll(result_mean, result_std);
107 
108  // Result from MATLAB:
109  const double good_M = 2.282504177034;
110  const double good_S = 0.660890754096;
111 
112  EXPECT_NEAR(std::abs(result_mean - good_M), 0, 1e-4);
113  EXPECT_NEAR(std::abs(result_std - good_S), 0, 1e-4);
114 }
115 
116 TEST(Matrices, laplacian)
117 {
118  // The laplacian matrix of W is L = D - W. (D:diagonals with degrees of
119  // nodes)
120  const double W_vals[6 * 6] = {0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0,
121  0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1,
122  1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0};
123  const CMatrixDouble W(6, 6, W_vals);
124 
125  CMatrixDouble L;
126  W.laplacian(L);
127 
128  const double real_laplacian_vals[6 * 6] = {
129  2, -1, 0, 0, -1, 0, -1, 3, -1, 0, -1, 0, 0, -1, 2, -1, 0, 0,
130  0, 0, -1, 3, -1, -1, -1, -1, 0, -1, 3, 0, 0, 0, 0, -1, 0, 1};
131  const CMatrixDouble GT_L(6, 6, real_laplacian_vals);
132 
133  EXPECT_NEAR((GT_L - L).array().abs().sum(), 0, 1e-4);
134 }
135 
136 TEST(Matrices, largestEigenvector)
137 {
138  {
139  const double dat_C1[] = {13.737245, 10.248641, -5.839599, 11.108320,
140  10.248641, 14.966139, -5.259922, 11.662222,
141  -5.839599, -5.259922, 9.608822, -4.342505,
142  11.108320, 11.662222, -4.342505, 12.121940};
143  const CMatrixDouble44 C1(dat_C1);
144 
145  const double dat_REAL_EIGVEC[] = {0.54800, 0.57167, -0.29604, 0.53409};
146  const Eigen::Matrix<double, 4, 1> REAL_EIGVEC(dat_REAL_EIGVEC);
147  // const double REAL_LARGEST_EIGENVALUE = 38.40966;
148 
149  mrpt::math::CVectorDouble lev;
150  C1.largestEigenvector(lev, 1e-3, 20);
151  EXPECT_NEAR((REAL_EIGVEC - lev).array().abs().sum(), 0, 1e-3);
152  }
153 }
154 
155 TEST(Matrices, loadFromTextFile)
156 {
157  {
158  const std::string s1 =
159  "1 2 3\n"
160  "4 5 6";
161  std::stringstream s(s1);
162  CMatrixDouble M;
163  bool retval = false;
164  try
165  {
166  M.loadFromTextFile(s);
167  retval = true;
168  }
169  catch (std::exception& e)
170  {
171  std::cerr << e.what() << std::endl;
172  }
173  EXPECT_TRUE(retval) << "string:\n" << s1 << endl;
174  EXPECT_EQ(M.rows(), 2);
175  EXPECT_EQ(M.cols(), 3);
176  }
177  {
178  const std::string s1 =
179  "1 \t 2\n"
180  " 4 \t\t 1 ";
181  std::stringstream s(s1);
182  CMatrixDouble M;
183  bool retval = false;
184  try
185  {
186  M.loadFromTextFile(s);
187  retval = true;
188  }
189  catch (std::exception& e)
190  {
191  std::cerr << e.what() << std::endl;
192  }
193  EXPECT_TRUE(retval) << "string:\n" << s1 << endl;
194  EXPECT_EQ(M.rows(), 2);
195  EXPECT_EQ(M.cols(), 2);
196  }
197  {
198  const std::string s1 = "1 2";
199  std::stringstream s(s1);
200  CMatrixDouble M;
201  bool retval = false;
202  try
203  {
204  M.loadFromTextFile(s);
205  retval = true;
206  }
207  catch (std::exception& e)
208  {
209  std::cerr << e.what() << std::endl;
210  }
211  EXPECT_TRUE(retval) << "string:\n" << s1 << endl;
212  EXPECT_EQ(M.rows(), 1);
213  EXPECT_EQ(M.cols(), 2);
214  }
215  {
216  const std::string s1 =
217  "1 2 3\n"
218  "4 5 6\n";
219  std::stringstream s(s1);
220  CMatrixFixedNumeric<double, 2, 3> M;
221  bool retval = false;
222  try
223  {
224  M.loadFromTextFile(s);
225  retval = true;
226  }
227  catch (std::exception& e)
228  {
229  std::cerr << e.what() << std::endl;
230  }
231  EXPECT_TRUE(retval) << "string:\n" << s1 << endl;
232  EXPECT_EQ(M.rows(), 2);
233  EXPECT_EQ(M.cols(), 3);
234  }
235  {
236  const std::string s1 =
237  "1 2 3\n"
238  "4 5\n";
239  std::stringstream s(s1);
240  CMatrixFixedNumeric<double, 2, 3> M;
241  bool retval = false;
242  try
243  {
244  M.loadFromTextFile(s);
245  retval = true;
246  }
247  catch (std::exception&)
248  {
249  }
250  EXPECT_FALSE(retval) << "string:\n" << s1 << endl;
251  }
252  {
253  const std::string s1 =
254  "1 2 3\n"
255  "4 5\n";
256  std::stringstream s(s1);
257  CMatrixDouble M;
258  bool retval = false;
259  try
260  {
261  M.loadFromTextFile(s);
262  retval = true;
263  }
264  catch (std::exception&)
265  {
266  }
267  EXPECT_FALSE(retval) << "string:\n" << s1 << endl;
268  }
269  {
270  const std::string s1 = " \n";
271  std::stringstream s(s1);
272  CMatrixFixedNumeric<double, 2, 3> M;
273  bool retval = false;
274  try
275  {
276  M.loadFromTextFile(s);
277  retval = true;
278  }
279  catch (std::exception&)
280  {
281  }
282  EXPECT_FALSE(retval) << "string:\n" << s1 << endl;
283  }
284  {
285  const std::string s1 =
286  "1 2 3\n"
287  "1 2 3\n"
288  "1 2 3";
289  std::stringstream s(s1);
290  CMatrixFixedNumeric<double, 2, 3> M;
291  bool retval = false;
292  try
293  {
294  M.loadFromTextFile(s);
295  retval = true;
296  }
297  catch (std::exception&)
298  {
299  }
300  EXPECT_FALSE(retval) << "string:\n" << s1 << endl;
301  }
302 }
mrpt::random
A namespace of pseudo-random numbers genrators of diferent distributions.
Definition: RandomGenerators.h:25
meanAndStd
void meanAndStd(VEC &outMeanVector, VEC &outStdVector, const bool unbiased_variance=true) const
Computes a row with the mean values of each column in the matrix and the associated vector with the s...
Definition: eigen_plugins.h:445
CMatrixFixedNumeric.h
mrpt::utils
Classes for serialization, sockets, ini-file manipulation, streams, list of properties-values, timewatch, extensions to STL.
Definition: CParticleFilter.h:223
dat_A
const double dat_A[]
Definition: matrix_ops1_unittest.cpp:30
mrpt::math::dynamic_vector
Column vector, like Eigen::MatrixX*, but automatically initialized to zeros since construction...
Definition: eigen_frwds.h:42
std
STL namespace.
s
GLdouble s
Definition: glext.h:3676
TEST
TEST(Matrices, meanAndStd)
Definition: matrix_ops4_unittest.cpp:28
laplacian
EIGEN_STRONG_INLINE void laplacian(Eigen::MatrixBase< OtherDerived > &ret) const
Computes the laplacian of this square graph weight matrix.
Definition: eigen_plugins.h:328
mrpt::math::CMatrixFixedNumeric
A numeric matrix of compile-time fixed size.
Definition: CMatrixFixedNumeric.h:39
mrpt::math
This base provides a set of functions for maths stuff.
Definition: CArrayNumeric.h:19
largestEigenvector
void largestEigenvector(OUTVECT &x, Scalar resolution=Scalar(0.01), size_t maxIterations=6, int *out_Iterations=nullptr, float *out_estimatedResolution=nullptr) const
Efficiently computes only the biggest eigenvector of the matrix using the Power Method, and returns it in the passed vector "x".
Definition: eigen_plugins.h:375
mrpt::math::sum
CONTAINER::Scalar sum(const CONTAINER &v)
Computes the sum of all the elements.
Definition: ops_containers.h:211
mrpt::utils::metaprogramming
A set of utility objects for metaprogramming with STL algorithms.
Definition: metaprogramming.h:24
string
GLsizei const GLchar ** string
Definition: glext.h:4101
meanAndStdAll
void meanAndStdAll(double &outMean, double &outStd, const bool unbiased_variance=true) const
Computes the mean and standard deviation of all the elements in the matrix as a whole.
Definition: eigen_plugins.h:471
loadFromTextFile
void loadFromTextFile(const std::string &file)
Load matrix from a text file, compatible with MATLAB text format.
mrpt
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
Definition: CParticleFilter.h:17
CMemoryStream.h


Page generated by Doxygen 1.8.14 for MRPT 1.9.9 Git: ae4571287 Thu Nov 23 00:06:53 2017 +0100 at dom oct 27 23:51:55 CET 2019