Namespaces | Macros | Typedefs | Enumerations | Functions
indexed_view.cpp File Reference
#include <vector>
#include "main.h"
#include <array>

Namespaces

 test
 

Macros

#define MATCH(X, R)   match(X, R, #X)
 
#define VERIFY_EQ_INT(A, B)   VERIFY_IS_APPROX(int(A), int(B))
 

Typedefs

typedef std::pair< Index, Index > test::IndexPair
 

Enumerations

enum  DummyEnum { XX = 0 , YY = 1 }
 

Functions

int encode (Index i, Index j)
 
test::IndexPair decode (Index ij)
 
template<typename T >
bool match (const T &xpr, std::string ref, std::string str_xpr="")
 
template<typename T1 , typename T2 >
std::enable_if_t< internal::is_same< T1, T2 >::value, bool > is_same_eq (const T1 &a, const T2 &b)
 
template<typename T1 , typename T2 >
bool is_same_seq (const T1 &a, const T2 &b)
 
template<typename T1 , typename T2 >
std::enable_if_t< internal::is_same< T1, T2 >::value, bool > is_same_seq_type (const T1 &a, const T2 &b)
 
void check_indexed_view ()
 
void check_tutorial_examples ()
 
 EIGEN_DECLARE_TEST (indexed_view)
 

Macro Definition Documentation

◆ MATCH

#define MATCH (   X,
  R 
)    match(X, R, #X)

◆ VERIFY_EQ_INT

#define VERIFY_EQ_INT (   A,
  B 
)    VERIFY_IS_APPROX(int(A), int(B))

Enumeration Type Documentation

◆ DummyEnum

enum DummyEnum
Enumerator
XX 
YY 
63 { XX = 0, YY = 1 };
YY
@ YY
Definition: indexed_view.cpp:63
XX
@ XX
Definition: indexed_view.cpp:63

Function Documentation

◆ check_indexed_view()

void check_indexed_view ( )
65  {
66  Index n = 10;
67 
68  ArrayXd a = ArrayXd::LinSpaced(n, 0, n - 1);
69  Array<double, 1, Dynamic> b = a.transpose();
70 
71  ArrayXXi A = ArrayXXi::NullaryExpr(n, n, std::ref(encode));
72 
73  for (Index i = 0; i < n; ++i)
74  for (Index j = 0; j < n; ++j) VERIFY(decode(A(i, j)) == test::IndexPair(i, j));
75 
76  Array4i eii(4);
77  eii << 3, 1, 6, 5;
78  std::vector<int> veci(4);
79  Map<ArrayXi>(veci.data(), 4) = eii;
80 
81  VERIFY(MATCH(A(3, seq(9, 3, -1)), "309 308 307 306 305 304 303"));
82 
83  VERIFY(MATCH(A(seqN(2, 5), seq(9, 3, -1)),
84  "209 208 207 206 205 204 203\n"
85  "309 308 307 306 305 304 303\n"
86  "409 408 407 406 405 404 403\n"
87  "509 508 507 506 505 504 503\n"
88  "609 608 607 606 605 604 603"));
89 
90  VERIFY(MATCH(A(seqN(2, 5), 5),
91  "205\n"
92  "305\n"
93  "405\n"
94  "505\n"
95  "605"));
96 
97  VERIFY(MATCH(A(seqN(last, 5, -1), seq(2, last)),
98  "902 903 904 905 906 907 908 909\n"
99  "802 803 804 805 806 807 808 809\n"
100  "702 703 704 705 706 707 708 709\n"
101  "602 603 604 605 606 607 608 609\n"
102  "502 503 504 505 506 507 508 509"));
103 
104  VERIFY(MATCH(A(eii, veci),
105  "303 301 306 305\n"
106  "103 101 106 105\n"
107  "603 601 606 605\n"
108  "503 501 506 505"));
109 
110  VERIFY(MATCH(A(eii, all),
111  "300 301 302 303 304 305 306 307 308 309\n"
112  "100 101 102 103 104 105 106 107 108 109\n"
113  "600 601 602 603 604 605 606 607 608 609\n"
114  "500 501 502 503 504 505 506 507 508 509"));
115 
116  // take row number 3, and repeat it 5 times
117  VERIFY(MATCH(A(seqN(3, 5, 0), all),
118  "300 301 302 303 304 305 306 307 308 309\n"
119  "300 301 302 303 304 305 306 307 308 309\n"
120  "300 301 302 303 304 305 306 307 308 309\n"
121  "300 301 302 303 304 305 306 307 308 309\n"
122  "300 301 302 303 304 305 306 307 308 309"));
123 
124  VERIFY(MATCH(a(seqN(3, 3), 0), "3\n4\n5"));
125  VERIFY(MATCH(a(seq(3, 5)), "3\n4\n5"));
126  VERIFY(MATCH(a(seqN(3, 3, 1)), "3\n4\n5"));
127  VERIFY(MATCH(a(seqN(5, 3, -1)), "5\n4\n3"));
128 
129  VERIFY(MATCH(b(0, seqN(3, 3)), "3 4 5"));
130  VERIFY(MATCH(b(seq(3, 5)), "3 4 5"));
131  VERIFY(MATCH(b(seqN(3, 3, 1)), "3 4 5"));
132  VERIFY(MATCH(b(seqN(5, 3, -1)), "5 4 3"));
133 
134  VERIFY(MATCH(b(all), "0 1 2 3 4 5 6 7 8 9"));
135  VERIFY(MATCH(b(eii), "3 1 6 5"));
136 
137  Array44i B;
138  B.setRandom();
139  VERIFY((A(seqN(2, 5), 5)).ColsAtCompileTime == 1);
140  VERIFY((A(seqN(2, 5), 5)).RowsAtCompileTime == Dynamic);
141  VERIFY_EQ_INT((A(seqN(2, 5), 5)).InnerStrideAtCompileTime, A.InnerStrideAtCompileTime);
142  VERIFY_EQ_INT((A(seqN(2, 5), 5)).OuterStrideAtCompileTime, A.col(5).OuterStrideAtCompileTime);
143 
144  VERIFY_EQ_INT((A(5, seqN(2, 5))).InnerStrideAtCompileTime, A.row(5).InnerStrideAtCompileTime);
145  VERIFY_EQ_INT((A(5, seqN(2, 5))).OuterStrideAtCompileTime, A.row(5).OuterStrideAtCompileTime);
146  VERIFY_EQ_INT((B(1, seqN(1, 2))).InnerStrideAtCompileTime, B.row(1).InnerStrideAtCompileTime);
147  VERIFY_EQ_INT((B(1, seqN(1, 2))).OuterStrideAtCompileTime, B.row(1).OuterStrideAtCompileTime);
148 
149  VERIFY_EQ_INT((A(seqN(2, 5), seq(1, 3))).InnerStrideAtCompileTime, A.InnerStrideAtCompileTime);
150  VERIFY_EQ_INT((A(seqN(2, 5), seq(1, 3))).OuterStrideAtCompileTime, A.OuterStrideAtCompileTime);
151  VERIFY_EQ_INT((B(seqN(1, 2), seq(1, 3))).InnerStrideAtCompileTime, B.InnerStrideAtCompileTime);
152  VERIFY_EQ_INT((B(seqN(1, 2), seq(1, 3))).OuterStrideAtCompileTime, B.OuterStrideAtCompileTime);
153  VERIFY_EQ_INT((A(seqN(2, 5, 2), seq(1, 3, 2))).InnerStrideAtCompileTime, Dynamic);
154  VERIFY_EQ_INT((A(seqN(2, 5, 2), seq(1, 3, 2))).OuterStrideAtCompileTime, Dynamic);
155  VERIFY_EQ_INT((A(seqN(2, 5, fix<2>), seq(1, 3, fix<3>))).InnerStrideAtCompileTime, 2);
156  VERIFY_EQ_INT((A(seqN(2, 5, fix<2>), seq(1, 3, fix<3>))).OuterStrideAtCompileTime, Dynamic);
157  VERIFY_EQ_INT((B(seqN(1, 2, fix<2>), seq(1, 3, fix<3>))).InnerStrideAtCompileTime, 2);
158  VERIFY_EQ_INT((B(seqN(1, 2, fix<2>), seq(1, 3, fix<3>))).OuterStrideAtCompileTime, 3 * 4);
159 
160  VERIFY_EQ_INT((A(seqN(2, fix<5>), seqN(1, fix<3>))).RowsAtCompileTime, 5);
161  VERIFY_EQ_INT((A(seqN(2, fix<5>), seqN(1, fix<3>))).ColsAtCompileTime, 3);
162  VERIFY_EQ_INT((A(seqN(2, fix<5>(5)), seqN(1, fix<3>(3)))).RowsAtCompileTime, 5);
163  VERIFY_EQ_INT((A(seqN(2, fix<5>(5)), seqN(1, fix<3>(3)))).ColsAtCompileTime, 3);
164  VERIFY_EQ_INT((A(seqN(2, fix<Dynamic>(5)), seqN(1, fix<Dynamic>(3)))).RowsAtCompileTime, Dynamic);
165  VERIFY_EQ_INT((A(seqN(2, fix<Dynamic>(5)), seqN(1, fix<Dynamic>(3)))).ColsAtCompileTime, Dynamic);
166  VERIFY_EQ_INT((A(seqN(2, fix<Dynamic>(5)), seqN(1, fix<Dynamic>(3)))).rows(), 5);
167  VERIFY_EQ_INT((A(seqN(2, fix<Dynamic>(5)), seqN(1, fix<Dynamic>(3)))).cols(), 3);
168 
169  VERIFY(is_same_seq_type(seqN(2, 5, fix<-1>), seqN(2, 5, fix<-1>(-1))));
170  VERIFY(is_same_seq_type(seqN(2, 5), seqN(2, 5, fix<1>(1))));
171  VERIFY(is_same_seq_type(seqN(2, 5, 3), seqN(2, 5, fix<DynamicIndex>(3))));
172  VERIFY(is_same_seq_type(seq(2, 7, fix<3>), seqN(2, 2, fix<3>)));
173  VERIFY(is_same_seq_type(seqN(2, fix<Dynamic>(5), 3), seqN(2, 5, fix<DynamicIndex>(3))));
174  VERIFY(is_same_seq_type(seqN(2, fix<5>(5), fix<-2>), seqN(2, fix<5>, fix<-2>())));
175 
176  VERIFY(is_same_seq_type(seq(2, fix<5>), seqN(2, 4)));
177  VERIFY(is_same_seq_type(seq(fix<2>, fix<5>), seqN(fix<2>, fix<4>)));
178  VERIFY(is_same_seq(seqN(2, std::integral_constant<int, 5>(), std::integral_constant<int, -2>()),
179  seqN(2, fix<5>, fix<-2>())));
180  VERIFY(is_same_seq(
181  seq(std::integral_constant<int, 1>(), std::integral_constant<int, 5>(), std::integral_constant<int, 2>()),
182  seq(fix<1>, fix<5>, fix<2>())));
183  VERIFY(is_same_seq_type(seqN(2, std::integral_constant<int, 5>(), std::integral_constant<int, -2>()),
184  seqN(2, fix<5>, fix<-2>())));
185  VERIFY(is_same_seq_type(
186  seq(std::integral_constant<int, 1>(), std::integral_constant<int, 5>(), std::integral_constant<int, 2>()),
187  seq(fix<1>, fix<5>, fix<2>())));
188 
189  VERIFY(is_same_seq_type(seqN(2, std::integral_constant<int, 5>()), seqN(2, fix<5>)));
190  VERIFY(
191  is_same_seq_type(seq(std::integral_constant<int, 1>(), std::integral_constant<int, 5>()), seq(fix<1>, fix<5>)));
192 
193  VERIFY((A(seqN(2, fix<5>), 5)).RowsAtCompileTime == 5);
194  VERIFY((A(4, all)).ColsAtCompileTime == Dynamic);
195  VERIFY((A(4, all)).RowsAtCompileTime == 1);
196  VERIFY((B(1, all)).ColsAtCompileTime == 4);
197  VERIFY((B(1, all)).RowsAtCompileTime == 1);
198  VERIFY((B(all, 1)).ColsAtCompileTime == 1);
199  VERIFY((B(all, 1)).RowsAtCompileTime == 4);
200 
201  VERIFY(int((A(all, eii)).ColsAtCompileTime) == int(eii.SizeAtCompileTime));
202  VERIFY_EQ_INT((A(eii, eii)).Flags & DirectAccessBit, (unsigned int)(0));
203  VERIFY_EQ_INT((A(eii, eii)).InnerStrideAtCompileTime, 0);
204  VERIFY_EQ_INT((A(eii, eii)).OuterStrideAtCompileTime, 0);
205 
206  VERIFY_IS_APPROX(A(seq(n - 1, 2, -2), seqN(n - 1 - 6, 3, -1)), A(seq(last, 2, fix<-2>), seqN(last - 6, 3, fix<-1>)));
207 
208  VERIFY_IS_APPROX(A(seq(n - 1, 2, -2), seqN(n - 1 - 6, 4)), A(seq(last, 2, -2), seqN(last - 6, 4)));
209  VERIFY_IS_APPROX(A(seq(n - 1 - 6, n - 1 - 2), seqN(n - 1 - 6, 4)),
210  A(seq(last - 6, last - 2), seqN(6 + last - 6 - 6, 4)));
211  VERIFY_IS_APPROX(A(seq((n - 1) / 2, (n) / 2 + 3), seqN(2, 4)),
212  A(seq(last / 2, (last + 1) / 2 + 3), seqN(last + 2 - last, 4)));
213  VERIFY_IS_APPROX(A(seq(n - 2, 2, -2), seqN(n - 8, 4)), A(seq(lastp1 - 2, 2, -2), seqN(lastp1 - 8, 4)));
214 
215  // Check all combinations of seq:
216  VERIFY_IS_APPROX(A(seq(1, n - 1 - 2, 2), seq(1, n - 1 - 2, 2)), A(seq(1, last - 2, 2), seq(1, last - 2, fix<2>)));
217  VERIFY_IS_APPROX(A(seq(n - 1 - 5, n - 1 - 2, 2), seq(n - 1 - 5, n - 1 - 2, 2)),
218  A(seq(last - 5, last - 2, 2), seq(last - 5, last - 2, fix<2>)));
219  VERIFY_IS_APPROX(A(seq(n - 1 - 5, 7, 2), seq(n - 1 - 5, 7, 2)), A(seq(last - 5, 7, 2), seq(last - 5, 7, fix<2>)));
220  VERIFY_IS_APPROX(A(seq(1, n - 1 - 2), seq(n - 1 - 5, 7)), A(seq(1, last - 2), seq(last - 5, 7)));
221  VERIFY_IS_APPROX(A(seq(n - 1 - 5, n - 1 - 2), seq(n - 1 - 5, n - 1 - 2)),
222  A(seq(last - 5, last - 2), seq(last - 5, last - 2)));
223 
224  VERIFY_IS_APPROX(A.col(A.cols() - 1), A(all, last));
225  VERIFY_IS_APPROX(A(A.rows() - 2, A.cols() / 2), A(last - 1, lastp1 / 2));
226  VERIFY_IS_APPROX(a(a.size() - 2), a(last - 1));
227  VERIFY_IS_APPROX(a(a.size() / 2), a((last + 1) / 2));
228 
229  // Check fall-back to Block
230  {
231  VERIFY(is_same_eq(A.col(0), A(all, 0)));
232  VERIFY(is_same_eq(A.row(0), A(0, all)));
233  VERIFY(is_same_eq(A.block(0, 0, 2, 2), A(seqN(0, 2), seq(0, 1))));
234  VERIFY(is_same_eq(A.middleRows(2, 4), A(seqN(2, 4), all)));
235  VERIFY(is_same_eq(A.middleCols(2, 4), A(all, seqN(2, 4))));
236 
237  VERIFY(is_same_eq(A.col(A.cols() - 1), A(all, last)));
238 
239  const ArrayXXi& cA(A);
240  VERIFY(is_same_eq(cA.col(0), cA(all, 0)));
241  VERIFY(is_same_eq(cA.row(0), cA(0, all)));
242  VERIFY(is_same_eq(cA.block(0, 0, 2, 2), cA(seqN(0, 2), seq(0, 1))));
243  VERIFY(is_same_eq(cA.middleRows(2, 4), cA(seqN(2, 4), all)));
244  VERIFY(is_same_eq(cA.middleCols(2, 4), cA(all, seqN(2, 4))));
245 
246  VERIFY(is_same_eq(a.head(4), a(seq(0, 3))));
247  VERIFY(is_same_eq(a.tail(4), a(seqN(last - 3, 4))));
248  VERIFY(is_same_eq(a.tail(4), a(seq(lastp1 - 4, last))));
249  VERIFY(is_same_eq(a.segment<4>(3), a(seqN(3, fix<4>))));
250  }
251 
252  ArrayXXi A1 = A, A2 = ArrayXXi::Random(4, 4);
253  ArrayXi range25(4);
254  range25 << 3, 2, 4, 5;
255  A1(seqN(3, 4), seq(2, 5)) = A2;
256  VERIFY_IS_APPROX(A1.block(3, 2, 4, 4), A2);
257  A1 = A;
258  A2.setOnes();
259  A1(seq(6, 3, -1), range25) = A2;
260  VERIFY_IS_APPROX(A1.block(3, 2, 4, 4), A2);
261 
262  // check reverse
263  {
264  VERIFY(is_same_seq_type(seq(3, 7).reverse(), seqN(7, 5, fix<-1>)));
265  VERIFY(is_same_seq_type(seq(7, 3, fix<-2>).reverse(), seqN(3, 3, fix<2>)));
266  VERIFY_IS_APPROX(a(seqN(2, last / 2).reverse()), a(seqN(2 + (last / 2 - 1) * 1, last / 2, fix<-1>)));
267  VERIFY_IS_APPROX(a(seqN(last / 2, fix<4>).reverse()), a(seqN(last / 2, fix<4>)).reverse());
268  VERIFY_IS_APPROX(A(seq(last - 5, last - 1, 2).reverse(), seqN(last - 3, 3, fix<-2>).reverse()),
269  A(seq(last - 5, last - 1, 2), seqN(last - 3, 3, fix<-2>)).reverse());
270  }
271 
272  // check lastN
273  VERIFY_IS_APPROX(a(lastN(3)), a.tail(3));
274  VERIFY(MATCH(a(lastN(3)), "7\n8\n9"));
275  VERIFY_IS_APPROX(a(lastN(fix<3>())), a.tail<3>());
276  VERIFY(MATCH(a(lastN(3, 2)), "5\n7\n9"));
277  VERIFY(MATCH(a(lastN(3, fix<2>())), "5\n7\n9"));
278  VERIFY(a(lastN(fix<3>())).SizeAtCompileTime == 3);
279 
280  VERIFY((A(all, std::array<int, 4>{{1, 3, 2, 4}})).ColsAtCompileTime == 4);
281 
282  VERIFY_IS_APPROX((A(std::array<int, 3>{{1, 3, 5}}, std::array<int, 4>{{9, 6, 3, 0}})),
283  A(seqN(1, 3, 2), seqN(9, 4, -3)));
284  VERIFY_IS_EQUAL(A(std::array<int, 3>{1, 3, 5}, std::array<int, 4>{3, 1, 6, 5}).RowsAtCompileTime, 3);
285  VERIFY_IS_EQUAL(A(std::array<int, 3>{1, 3, 5}, std::array<int, 4>{3, 1, 6, 5}).ColsAtCompileTime, 4);
286 
287  VERIFY_IS_EQUAL(a(std::array<int, 3>{1, 3, 5}).SizeAtCompileTime, 3);
288  VERIFY_IS_EQUAL(b(std::array<int, 3>{1, 3, 5}).SizeAtCompileTime, 3);
289 
290  // check different index types (C-style array, STL container, Eigen type)
291  {
292  Index size = 10;
293  ArrayXd r = ArrayXd::Random(size);
294  ArrayXi idx = ArrayXi::EqualSpaced(size, 0, 1);
295  std::shuffle(idx.begin(), idx.end(), std::random_device());
296 
297  int c_array[3] = {idx[0], idx[1], idx[2]};
298  std::vector<int> std_vector{idx[0], idx[1], idx[2]};
299  Matrix<int, 3, 1> eigen_matrix{idx[0], idx[1], idx[2]};
300 
301  // non-const access
302  VERIFY_IS_CWISE_EQUAL(r({idx[0], idx[1], idx[2]}), r(c_array));
303  VERIFY_IS_CWISE_EQUAL(r({idx[0], idx[1], idx[2]}), r(std_vector));
304  VERIFY_IS_CWISE_EQUAL(r({idx[0], idx[1], idx[2]}), r(eigen_matrix));
305  VERIFY_IS_CWISE_EQUAL(r(std_vector), r(c_array));
306  VERIFY_IS_CWISE_EQUAL(r(std_vector), r(eigen_matrix));
307  VERIFY_IS_CWISE_EQUAL(r(eigen_matrix), r(c_array));
308 
309  const ArrayXd& r_ref = r;
310  // const access
311  VERIFY_IS_CWISE_EQUAL(r_ref({idx[0], idx[1], idx[2]}), r_ref(c_array));
312  VERIFY_IS_CWISE_EQUAL(r_ref({idx[0], idx[1], idx[2]}), r_ref(std_vector));
313  VERIFY_IS_CWISE_EQUAL(r_ref({idx[0], idx[1], idx[2]}), r_ref(eigen_matrix));
314  VERIFY_IS_CWISE_EQUAL(r_ref(std_vector), r_ref(c_array));
315  VERIFY_IS_CWISE_EQUAL(r_ref(std_vector), r_ref(eigen_matrix));
316  VERIFY_IS_CWISE_EQUAL(r_ref(eigen_matrix), r_ref(c_array));
317  }
318 
319  {
320  Index rows = 8;
321  Index cols = 11;
322  ArrayXXd R = ArrayXXd::Random(rows, cols);
323  ArrayXi r_idx = ArrayXi::EqualSpaced(rows, 0, 1);
324  ArrayXi c_idx = ArrayXi::EqualSpaced(cols, 0, 1);
325  std::shuffle(r_idx.begin(), r_idx.end(), std::random_device());
326  std::shuffle(c_idx.begin(), c_idx.end(), std::random_device());
327 
328  int c_array_rows[3] = {r_idx[0], r_idx[1], r_idx[2]};
329  int c_array_cols[4] = {c_idx[0], c_idx[1], c_idx[2], c_idx[3]};
330  std::vector<int> std_vector_rows{r_idx[0], r_idx[1], r_idx[2]};
331  std::vector<int> std_vector_cols{c_idx[0], c_idx[1], c_idx[2], c_idx[3]};
332  Matrix<int, 3, 1> eigen_matrix_rows{r_idx[0], r_idx[1], r_idx[2]};
333  Matrix<int, 4, 1> eigen_matrix_cols{c_idx[0], c_idx[1], c_idx[2], c_idx[3]};
334 
335  // non-const access
336  VERIFY_IS_CWISE_EQUAL(R({r_idx[0], r_idx[1], r_idx[2]}, {c_idx[0], c_idx[1], c_idx[2], c_idx[3]}),
337  R(c_array_rows, c_array_cols));
338  VERIFY_IS_CWISE_EQUAL(R({r_idx[0], r_idx[1], r_idx[2]}, {c_idx[0], c_idx[1], c_idx[2], c_idx[3]}),
339  R(std_vector_rows, std_vector_cols));
340  VERIFY_IS_CWISE_EQUAL(R({r_idx[0], r_idx[1], r_idx[2]}, {c_idx[0], c_idx[1], c_idx[2], c_idx[3]}),
341  R(eigen_matrix_rows, eigen_matrix_cols));
342  VERIFY_IS_CWISE_EQUAL(R(std_vector_rows, std_vector_cols), R(c_array_rows, c_array_cols));
343  VERIFY_IS_CWISE_EQUAL(R(std_vector_rows, std_vector_cols), R(eigen_matrix_rows, eigen_matrix_cols));
344  VERIFY_IS_CWISE_EQUAL(R(eigen_matrix_rows, eigen_matrix_cols), R(c_array_rows, c_array_cols));
345 
346  const ArrayXXd& R_ref = R;
347  // const access
348  VERIFY_IS_CWISE_EQUAL(R_ref({r_idx[0], r_idx[1], r_idx[2]}, {c_idx[0], c_idx[1], c_idx[2], c_idx[3]}),
349  R_ref(c_array_rows, c_array_cols));
350  VERIFY_IS_CWISE_EQUAL(R_ref({r_idx[0], r_idx[1], r_idx[2]}, {c_idx[0], c_idx[1], c_idx[2], c_idx[3]}),
351  R_ref(std_vector_rows, std_vector_cols));
352  VERIFY_IS_CWISE_EQUAL(R_ref({r_idx[0], r_idx[1], r_idx[2]}, {c_idx[0], c_idx[1], c_idx[2], c_idx[3]}),
353  R_ref(eigen_matrix_rows, eigen_matrix_cols));
354  VERIFY_IS_CWISE_EQUAL(R_ref(std_vector_rows, std_vector_cols), R_ref(c_array_rows, c_array_cols));
355  VERIFY_IS_CWISE_EQUAL(R_ref(std_vector_rows, std_vector_cols), R_ref(eigen_matrix_rows, eigen_matrix_cols));
356  VERIFY_IS_CWISE_EQUAL(R_ref(eigen_matrix_rows, eigen_matrix_cols), R_ref(c_array_rows, c_array_cols));
357  }
358 
359  // check mat(i,j) with weird types for i and j
360  {
361  VERIFY_IS_APPROX(A(B.RowsAtCompileTime - 1, 1), A(3, 1));
362  VERIFY_IS_APPROX(A(B.RowsAtCompileTime, 1), A(4, 1));
363  VERIFY_IS_APPROX(A(B.RowsAtCompileTime - 1, B.ColsAtCompileTime - 1), A(3, 3));
364  VERIFY_IS_APPROX(A(B.RowsAtCompileTime, B.ColsAtCompileTime), A(4, 4));
365  const Index I_ = 3, J_ = 4;
366  VERIFY_IS_APPROX(A(I_, J_), A(3, 4));
367  }
368 
369  // check extended block API
370  {
371  VERIFY(is_same_eq(A.block<3, 4>(1, 1), A.block(1, 1, fix<3>, fix<4>)));
372  VERIFY(is_same_eq(A.block<3, 4>(1, 1, 3, 4), A.block(1, 1, fix<3>(), fix<4>(4))));
373  VERIFY(is_same_eq(A.block<3, Dynamic>(1, 1, 3, 4), A.block(1, 1, fix<3>, 4)));
374  VERIFY(is_same_eq(A.block<Dynamic, 4>(1, 1, 3, 4), A.block(1, 1, fix<Dynamic>(3), fix<4>)));
375  VERIFY(is_same_eq(A.block(1, 1, 3, 4), A.block(1, 1, fix<Dynamic>(3), fix<Dynamic>(4))));
376 
377  VERIFY(is_same_eq(A.topLeftCorner<3, 4>(), A.topLeftCorner(fix<3>, fix<4>)));
378  VERIFY(is_same_eq(A.bottomLeftCorner<3, 4>(), A.bottomLeftCorner(fix<3>, fix<4>)));
379  VERIFY(is_same_eq(A.bottomRightCorner<3, 4>(), A.bottomRightCorner(fix<3>, fix<4>)));
380  VERIFY(is_same_eq(A.topRightCorner<3, 4>(), A.topRightCorner(fix<3>, fix<4>)));
381 
382  VERIFY(is_same_eq(A.leftCols<3>(), A.leftCols(fix<3>)));
383  VERIFY(is_same_eq(A.rightCols<3>(), A.rightCols(fix<3>)));
384  VERIFY(is_same_eq(A.middleCols<3>(1), A.middleCols(1, fix<3>)));
385 
386  VERIFY(is_same_eq(A.topRows<3>(), A.topRows(fix<3>)));
387  VERIFY(is_same_eq(A.bottomRows<3>(), A.bottomRows(fix<3>)));
388  VERIFY(is_same_eq(A.middleRows<3>(1), A.middleRows(1, fix<3>)));
389 
390  VERIFY(is_same_eq(a.segment<3>(1), a.segment(1, fix<3>)));
391  VERIFY(is_same_eq(a.head<3>(), a.head(fix<3>)));
392  VERIFY(is_same_eq(a.tail<3>(), a.tail(fix<3>)));
393 
394  const ArrayXXi& cA(A);
395  VERIFY(is_same_eq(cA.block<Dynamic, 4>(1, 1, 3, 4), cA.block(1, 1, fix<Dynamic>(3), fix<4>)));
396 
397  VERIFY(is_same_eq(cA.topLeftCorner<3, 4>(), cA.topLeftCorner(fix<3>, fix<4>)));
398  VERIFY(is_same_eq(cA.bottomLeftCorner<3, 4>(), cA.bottomLeftCorner(fix<3>, fix<4>)));
399  VERIFY(is_same_eq(cA.bottomRightCorner<3, 4>(), cA.bottomRightCorner(fix<3>, fix<4>)));
400  VERIFY(is_same_eq(cA.topRightCorner<3, 4>(), cA.topRightCorner(fix<3>, fix<4>)));
401 
402  VERIFY(is_same_eq(cA.leftCols<3>(), cA.leftCols(fix<3>)));
403  VERIFY(is_same_eq(cA.rightCols<3>(), cA.rightCols(fix<3>)));
404  VERIFY(is_same_eq(cA.middleCols<3>(1), cA.middleCols(1, fix<3>)));
405 
406  VERIFY(is_same_eq(cA.topRows<3>(), cA.topRows(fix<3>)));
407  VERIFY(is_same_eq(cA.bottomRows<3>(), cA.bottomRows(fix<3>)));
408  VERIFY(is_same_eq(cA.middleRows<3>(1), cA.middleRows(1, fix<3>)));
409  }
410 
411  // Check compilation of enums as index type:
412  a(XX) = 1;
413  A(XX, YY) = 1;
414  // Anonymous enums only work with C++11
415  enum { X = 0, Y = 1 };
416  a(X) = 1;
417  A(X, Y) = 1;
418  A(XX, Y) = 1;
419  A(X, YY) = 1;
420  // check symbolic indices
421  a(last) = 1.0;
422  A(last, last) = 1;
423  // check weird non-const, non-lvalue scenarios
424  {
425  // in these scenarios, the objects are not declared 'const', and the compiler will atttempt to use the non-const
426  // overloads without intervention
427 
428  // non-const map to a const object
429  Map<const ArrayXd> a_map(a.data(), a.size());
430  Map<const ArrayXXi> A_map(A.data(), A.rows(), A.cols());
431 
432  VERIFY_IS_EQUAL(a_map(last), a.coeff(a.size() - 1));
433  VERIFY_IS_EQUAL(A_map(last, last), A.coeff(A.rows() - 1, A.cols() - 1));
434 
435  // non-const expressions that have no modifiable data
436  using Op = internal::scalar_constant_op<double>;
437  using VectorXpr = CwiseNullaryOp<Op, VectorXd>;
438  using MatrixXpr = CwiseNullaryOp<Op, MatrixXd>;
439  double constant_val = internal::random<double>();
440  Op op(constant_val);
441  VectorXpr vectorXpr(10, 1, op);
442  MatrixXpr matrixXpr(8, 11, op);
443 
444  VERIFY_IS_EQUAL(vectorXpr.coeff(vectorXpr.size() - 1), vectorXpr(last));
445  VERIFY_IS_EQUAL(matrixXpr.coeff(matrixXpr.rows() - 1, matrixXpr.cols() - 1), matrixXpr(last, last));
446  }
447 
448  // Check compilation of varying integer types as index types:
449  Index i = n / 2;
450  short i_short = static_cast<short>(i);
451  std::size_t i_sizet(i);
452  VERIFY_IS_EQUAL(a(i), a.coeff(i_short));
453  VERIFY_IS_EQUAL(a(i), a.coeff(i_sizet));
454 
455  VERIFY_IS_EQUAL(A(i, i), A.coeff(i_short, i_short));
456  VERIFY_IS_EQUAL(A(i, i), A.coeff(i_short, i));
457  VERIFY_IS_EQUAL(A(i, i), A.coeff(i, i_short));
458  VERIFY_IS_EQUAL(A(i, i), A.coeff(i, i_sizet));
459  VERIFY_IS_EQUAL(A(i, i), A.coeff(i_sizet, i));
460  VERIFY_IS_EQUAL(A(i, i), A.coeff(i_sizet, i_short));
461  VERIFY_IS_EQUAL(A(i, i), A.coeff(5, i_sizet));
462 
463  // Regression test for Max{Rows,Cols}AtCompileTime
464  {
465  Matrix3i A3 = Matrix3i::Random();
466  ArrayXi ind(5);
467  ind << 1, 1, 1, 1, 1;
468  VERIFY_IS_EQUAL(A3(ind, ind).eval(), MatrixXi::Constant(5, 5, A3(1, 1)));
469  }
470 
471  // Regression for bug 1736
472  {
473  VERIFY_IS_APPROX(A(all, eii).col(0).eval(), A.col(eii(0)));
474  A(all, eii).col(0) = A.col(eii(0));
475  }
476 
477  // bug 1815: IndexedView should allow linear access
478  {
479  VERIFY(MATCH(b(eii)(0), "3"));
480  VERIFY(MATCH(a(eii)(0), "3"));
481  VERIFY(MATCH(A(1, eii)(0), "103"));
482  VERIFY(MATCH(A(eii, 1)(0), "301"));
483  VERIFY(MATCH(A(1, all)(1), "101"));
484  VERIFY(MATCH(A(all, 1)(1), "101"));
485  }
486 
487  // bug #2375: indexing over matrices of dim >128 should compile on gcc
488  {
489  Matrix<double, 513, 3> large_mat = Matrix<double, 513, 3>::Random();
490  std::array<int, 2> test_indices = {0, 1};
491  Matrix<double, 513, 2> thin_slice = large_mat(all, test_indices);
492  for (int col = 0; col < int(test_indices.size()); ++col)
493  for (int row = 0; row < large_mat.rows(); ++row) VERIFY_IS_EQUAL(thin_slice(row, col), large_mat(row, col));
494  }
495 
496  // Bug IndexView with a single static row should be RowMajor:
497  {
498  // A(1, seq(0,2,1)).cwiseAbs().colwise().replicate(2).eval();
499  STATIC_CHECK(((internal::evaluator<decltype(A(1, seq(0, 2, 1)))>::Flags & RowMajorBit) == RowMajorBit));
500  }
501 
502  // Direct access.
503  {
504  int rows = 3;
505  int row_start = internal::random<int>(0, rows - 1);
506  int row_inc = internal::random<int>(1, rows - row_start);
507  int row_size = internal::random<int>(1, (rows - row_start) / row_inc);
508  auto row_seq = seqN(row_start, row_size, row_inc);
509 
510  int cols = 3;
511  int col_start = internal::random<int>(0, cols - 1);
512  int col_inc = internal::random<int>(1, cols - col_start);
513  int col_size = internal::random<int>(1, (cols - col_start) / col_inc);
514  auto col_seq = seqN(col_start, col_size, col_inc);
515 
516  MatrixXd m1 = MatrixXd::Random(rows, cols);
517  MatrixXd m2 = MatrixXd::Random(cols, rows);
518  VERIFY_IS_APPROX(m1(row_seq, indexing::all) * m2, m1(row_seq, indexing::all).eval() * m2);
519  VERIFY_IS_APPROX(m1 * m2(indexing::all, col_seq), m1 * m2(indexing::all, col_seq).eval());
520  VERIFY_IS_APPROX(m1(row_seq, col_seq) * m2(col_seq, row_seq),
521  m1(row_seq, col_seq).eval() * m2(col_seq, row_seq).eval());
522 
523  VectorXd v1 = VectorXd::Random(cols);
524  VERIFY_IS_APPROX(m1(row_seq, col_seq) * v1(col_seq), m1(row_seq, col_seq).eval() * v1(col_seq).eval());
525  VERIFY_IS_APPROX(v1(col_seq).transpose() * m2(col_seq, row_seq),
526  v1(col_seq).transpose().eval() * m2(col_seq, row_seq).eval());
527  }
528 }
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
n
const unsigned n
Definition: CG3DPackingUnitTest.cpp:11
m1
Matrix3d m1
Definition: IOFormat.cpp:2
col
m col(1)
row
m row(1)
ind
std::vector< int > ind
Definition: Slicing_stdvector_cxx11.cpp:1
R
@ R
Definition: StatisticsVector.h:21
m2
MatrixType m2(n_dims)
v1
M1<< 1, 2, 3, 4, 5, 6, 7, 8, 9;Map< RowVectorXf > v1(M1.data(), M1.size())
rows
int rows
Definition: Tutorial_commainit_02.cpp:1
cols
int cols
Definition: Tutorial_commainit_02.cpp:1
reverse
void reverse(const MatrixType &m)
Definition: array_reverse.cpp:17
size
Scalar Scalar int size
Definition: benchVecAdd.cpp:17
b
Scalar * b
Definition: benchVecAdd.cpp:17
A
Matrix< SCALARA, Dynamic, Dynamic, opt_A > A
Definition: bench_gemm.cpp:47
B
Matrix< SCALARB, Dynamic, Dynamic, opt_B > B
Definition: bench_gemm.cpp:48
Eigen::Array
General-purpose arrays with easy API for coefficient-wise operations.
Definition: Array.h:48
Eigen::CwiseNullaryOp
Generic expression of a matrix where all coefficients are defined by a functor.
Definition: CwiseNullaryOp.h:64
Eigen::Map
A matrix or vector expression mapping an existing array of data.
Definition: Map.h:96
Eigen::Matrix
The matrix class, also used for vectors and row-vectors.
Definition: Eigen/Eigen/src/Core/Matrix.h:186
Eigen::PlainObjectBase::setOnes
EIGEN_DEVICE_FUNC Derived & setOnes(Index size)
Definition: CwiseNullaryOp.h:708
Eigen::PlainObjectBase::coeff
EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const Scalar & coeff(Index rowId, Index colId) const
Definition: PlainObjectBase.h:198
Eigen::PlainObjectBase::data
constexpr EIGEN_DEVICE_FUNC const Scalar * data() const
Definition: PlainObjectBase.h:273
Eigen::PlainObjectBase::cols
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT
Definition: PlainObjectBase.h:192
Eigen::PlainObjectBase::rows
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT
Definition: PlainObjectBase.h:191
oomph::Matrix
Definition: matrices.h:74
Eigen::placeholders::all
static constexpr Eigen::internal::all_t all
Definition: IndexedViewHelper.h:86
Eigen::placeholders::last
static constexpr const last_t last
Definition: IndexedViewHelper.h:48
Eigen::placeholders::lastp1
static constexpr lastp1_t lastp1
Definition: IndexedViewHelper.h:72
Eigen::DirectAccessBit
const unsigned int DirectAccessBit
Definition: Constants.h:159
Eigen::RowMajorBit
const unsigned int RowMajorBit
Definition: Constants.h:70
X
#define X
Definition: icosphere.cpp:20
MATCH
#define MATCH(X, R)
Definition: indexed_view.cpp:37
is_same_seq
bool is_same_seq(const T1 &a, const T2 &b)
Definition: indexed_view.cpp:45
decode
test::IndexPair decode(Index ij)
Definition: indexed_view.cpp:26
is_same_seq_type
std::enable_if_t< internal::is_same< T1, T2 >::value, bool > is_same_seq_type(const T1 &a, const T2 &b)
Definition: indexed_view.cpp:56
encode
int encode(Index i, Index j)
Definition: indexed_view.cpp:24
VERIFY_EQ_INT
#define VERIFY_EQ_INT(A, B)
Definition: indexed_view.cpp:60
is_same_eq
std::enable_if_t< internal::is_same< T1, T2 >::value, bool > is_same_eq(const T1 &a, const T2 &b)
Definition: indexed_view.cpp:40
VERIFY_IS_APPROX
#define VERIFY_IS_APPROX(a, b)
Definition: integer_types.cpp:13
int
return int(ret)+1
a
const Scalar * a
Definition: level2_cplx_impl.h:32
op
char char * op
Definition: level2_impl.h:374
VERIFY_IS_CWISE_EQUAL
#define VERIFY_IS_CWISE_EQUAL(a, b)
Definition: main.h:375
VERIFY
#define VERIFY(a)
Definition: main.h:362
STATIC_CHECK
#define STATIC_CHECK(COND)
Definition: main.h:380
VERIFY_IS_EQUAL
#define VERIFY_IS_EQUAL(a, b)
Definition: main.h:367
Eigen::internal::shuffle
EIGEN_STRONG_INLINE Packet2d shuffle(const Packet2d &m, const Packet2d &n, int mask)
Definition: LSX/PacketMath.h:150
Eigen::placeholders::lastN
auto lastN(SizeType size, IncrType incr) -> decltype(seqN(Eigen::placeholders::last -(size - fix< 1 >()) *incr, size, incr))
Definition: ArithmeticSequence.h:188
Eigen::seqN
ArithmeticSequence< typename internal::cleanup_index_type< FirstType >::type, typename internal::cleanup_index_type< SizeType >::type, typename internal::cleanup_seq_incr< IncrType >::type > seqN(FirstType first, SizeType size, IncrType incr)
Definition: ArithmeticSequence.h:105
Eigen::seq
auto seq(FirstType f, LastType l) -> decltype(seqN(typename internal::cleanup_index_type< FirstType >::type(f),(typename internal::cleanup_index_type< LastType >::type(l) - typename internal::cleanup_index_type< FirstType >::type(f)+fix< 1 >())))
Definition: ArithmeticSequence.h:152
Eigen::Index
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:83
Eigen::Dynamic
const int Dynamic
Definition: Constants.h:25
Flags
Extend namespace for flags.
Definition: fsi_chan_precond_driver.cc:56
UniformPSDSelfTest.r
r
Definition: UniformPSDSelfTest.py:20
anonymous_namespace{skew_symmetric_matrix3.cpp}::transpose
void transpose()
Definition: skew_symmetric_matrix3.cpp:135
test::IndexPair
std::pair< Index, Index > IndexPair
Definition: indexed_view.cpp:21
eval
internal::nested_eval< T, 1 >::type eval(const T &xpr)
Definition: sparse_permutations.cpp:47
Eigen::MatrixXpr
Definition: Constants.h:534
Y
const char Y
Definition: test/EulerAngles.cpp:32
j
std::ptrdiff_t j
Definition: tut_arithmetic_redux_minmax.cpp:2

References a, Eigen::placeholders::all, b, Eigen::PlainObjectBase< Derived >::coeff(), col(), cols, Eigen::PlainObjectBase< Derived >::cols(), Eigen::PlainObjectBase< Derived >::data(), decode(), Eigen::DirectAccessBit, Eigen::Dynamic, encode(), eval(), i, ind, int(), is_same_eq(), is_same_seq(), is_same_seq_type(), j, Eigen::placeholders::last, Eigen::placeholders::lastN(), Eigen::placeholders::lastp1, m1, m2(), MATCH, n, op, UniformPSDSelfTest::r, R, reverse(), row(), Eigen::RowMajorBit, rows, Eigen::PlainObjectBase< Derived >::rows(), Eigen::seq(), Eigen::seqN(), Eigen::PlainObjectBase< Derived >::setOnes(), Eigen::internal::shuffle(), size, STATIC_CHECK, anonymous_namespace{skew_symmetric_matrix3.cpp}::transpose(), v1(), VERIFY, VERIFY_EQ_INT, VERIFY_IS_APPROX, VERIFY_IS_CWISE_EQUAL, VERIFY_IS_EQUAL, X, XX, Y, and YY.

Referenced by EIGEN_DECLARE_TEST().

◆ check_tutorial_examples()

void check_tutorial_examples ( )
530  {
531  constexpr int kRows = 11;
532  constexpr int kCols = 21;
533  Matrix<double, kRows, kCols> A = Matrix<double, kRows, kCols>::Random();
534  Vector<double, kRows> v = Vector<double, kRows>::Random();
535 
536  {
537  auto slice = A(seqN(fix<0>, fix<5>, fix<2>), seqN(fix<2>, fix<7>, fix<1>));
538  EIGEN_UNUSED_VARIABLE(slice);
539  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), 5);
540  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), 7);
541  }
542  {
543  auto slice = A(seqN(fix<0>, fix<5>, fix<2>), indexing::all);
544  EIGEN_UNUSED_VARIABLE(slice);
545  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), 5);
546  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), kCols);
547  }
548 
549  // Examples from slicing tutorial.
550  // Bottom-left corner.
551  {
552  Index i = 3;
553  Index n = 5;
554  auto slice = A(seq(i, indexing::last), seqN(0, n));
555  auto block = A.bottomLeftCorner(A.rows() - i, n);
556  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
557  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
558  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), Dynamic);
559  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), Dynamic);
560  VERIFY_IS_EQUAL(slice, block);
561  }
562  {
563  auto i = fix<3>;
564  auto n = fix<5>;
565  auto slice = A(seq(i, indexing::last), seqN(fix<0>, n));
566  auto block = A.bottomLeftCorner(fix<kRows> - i, n);
567  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
568  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
569  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), A.RowsAtCompileTime - i);
570  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), n);
571  VERIFY_IS_EQUAL(slice, block);
572  }
573 
574  // Block starting at i,j of size m,n.
575  {
576  Index i = 4;
577  Index j = 2;
578  Index m = 3;
579  Index n = 5;
580  auto slice = A(seqN(i, m), seqN(j, n));
581  auto block = A.block(i, j, m, n);
582  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
583  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
584  VERIFY_IS_EQUAL(slice, block);
585  }
586  {
587  auto i = fix<4>;
588  auto j = fix<2>;
589  auto m = fix<3>;
590  auto n = fix<5>;
591  auto slice = A(seqN(i, m), seqN(j, n));
592  auto block = A.block(i, j, m, n);
593  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
594  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
595  VERIFY_IS_EQUAL(slice, block);
596  }
597 
598  // Block starting at i0,j0 and ending at i1,j1.
599  {
600  Index i0 = 4;
601  Index i1 = 7;
602  Index j0 = 3;
603  Index j1 = 5;
604  auto slice = A(seq(i0, i1), seq(j0, j1));
605  auto block = A.block(i0, j0, i1 - i0 + 1, j1 - j0 + 1);
606  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
607  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
608  VERIFY_IS_EQUAL(slice, block);
609  }
610  {
611  auto i0 = fix<4>;
612  auto i1 = fix<7>;
613  auto j0 = fix<3>;
614  auto j1 = fix<5>;
615  auto slice = A(seq(i0, i1), seq(j0, j1));
616  auto block = A.block(i0, j0, i1 - i0 + fix<1>, j1 - j0 + fix<1>);
617  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
618  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
619  VERIFY_IS_EQUAL(slice, block);
620  }
621 
622  // Even columns of A.
623  {
624  auto slice = A(all, seq(0, last, 2));
625  auto block =
626  Eigen::Map<Eigen::Matrix<double, kRows, Dynamic>, 0, OuterStride<2 * kRows>>(A.data(), kRows, (kCols + 1) / 2);
627  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
628  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
629  VERIFY_IS_EQUAL(slice, block);
630  }
631  {
632  auto slice = A(all, seq(fix<0>, last, fix<2>));
633  auto block = Eigen::Map<Eigen::Matrix<double, kRows, (kCols + 1) / 2>, 0, OuterStride<2 * kRows>>(A.data());
634  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
635  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
636  VERIFY_IS_EQUAL(slice, block);
637  }
638 
639  // First n odd rows of A.
640  {
641  Index n = 3;
642  auto slice = A(seqN(1, n, 2), all);
643  auto block = Eigen::Map<Eigen::Matrix<double, Dynamic, kCols>, 0, Stride<kRows, 2>>(A.data() + 1, n, kCols);
644  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
645  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
646  VERIFY_IS_EQUAL(slice, block);
647  }
648  {
649  auto n = fix<3>;
650  auto slice = A(seqN(fix<1>, n, fix<2>), all);
651  auto block = Eigen::Map<Eigen::Matrix<double, 3, kCols>, 0, Stride<kRows, 2>>(A.data() + 1);
652  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
653  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
654  VERIFY_IS_EQUAL(slice, block);
655  }
656 
657  // The second-last column.
658  {
659  auto slice = A(all, last - 1);
660  auto block = A.col(A.cols() - 2);
661  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
662  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
663  VERIFY_IS_EQUAL(slice, block);
664  }
665  {
666  auto slice = A(all, last - fix<1>);
667  auto block = A.col(fix<kCols> - fix<2>);
668  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
669  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
670  VERIFY_IS_EQUAL(slice, block);
671  }
672 
673  // The middle row.
674  {
675  auto slice = A(last / 2, all);
676  auto block = A.row((A.rows() - 1) / 2);
677  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
678  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
679  VERIFY_IS_EQUAL(slice, block);
680  }
681  {
682  auto slice = A(last / fix<2>, all);
683  auto block = A.row(fix<(kRows - 1) / 2>);
684  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
685  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
686  VERIFY_IS_EQUAL(slice, block);
687  }
688 
689  // Last elements of v starting at i.
690  {
691  Index i = 7;
692  auto slice = v(seq(i, last));
693  auto block = v.tail(v.size() - i);
694  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
695  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
696  VERIFY_IS_EQUAL(slice, block);
697  }
698  {
699  auto i = fix<7>;
700  auto slice = v(seq(i, last));
701  auto block = v.tail(fix<kRows> - i);
702  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
703  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
704  VERIFY_IS_EQUAL(slice, block);
705  }
706 
707  // Last n elements of v.
708  {
709  Index n = 6;
710  auto slice = v(seq(last + 1 - n, last));
711  auto block = v.tail(n);
712  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
713  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
714  VERIFY_IS_EQUAL(slice, block);
715  }
716  {
717  auto n = fix<6>;
718  auto slice = v(seq(last + fix<1> - n, last));
719  auto block = v.tail(n);
720  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
721  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
722  VERIFY_IS_EQUAL(slice, block);
723  }
724 
725  // Last n elements of v.
726  {
727  Index n = 6;
728  auto slice = v(lastN(n));
729  auto block = v.tail(n);
730  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
731  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
732  VERIFY_IS_EQUAL(slice, block);
733  }
734  {
735  auto n = fix<6>;
736  auto slice = v(lastN(n));
737  auto block = v.tail(n);
738  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
739  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
740  VERIFY_IS_EQUAL(slice, block);
741  }
742 
743  // Bottom-right corner of A of size m times n.
744  {
745  Index m = 3;
746  Index n = 6;
747  auto slice = A(lastN(m), lastN(n));
748  auto block = A.bottomRightCorner(m, n);
749  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
750  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
751  VERIFY_IS_EQUAL(slice, block);
752  }
753  {
754  auto m = fix<3>;
755  auto n = fix<6>;
756  auto slice = A(lastN(m), lastN(n));
757  auto block = A.bottomRightCorner(m, n);
758  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
759  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
760  VERIFY_IS_EQUAL(slice, block);
761  }
762 
763  // Last n columns with a stride of 3.
764  {
765  Index n = 4;
766  constexpr Index stride = 3;
767  auto slice = A(all, lastN(n, stride));
768  auto block = Eigen::Map<Eigen::Matrix<double, kRows, Dynamic>, 0, OuterStride<stride * kRows>>(
769  A.data() + (kCols - 1 - (n - 1) * stride) * kRows, A.rows(), n);
770  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
771  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
772  VERIFY_IS_EQUAL(slice, block);
773  }
774  {
775  constexpr auto n = fix<4>;
776  constexpr auto stride = fix<3>;
777  auto slice = A(all, lastN(n, stride));
778  auto block = Eigen::Map<Eigen::Matrix<double, kRows, n>, 0, OuterStride<stride * kRows>>(
779  A.data() + (kCols - 1 - (n - 1) * stride) * kRows, A.rows(), n);
780  VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
781  VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
782  VERIFY_IS_EQUAL(slice, block);
783  }
784 
785  // Compile time size and increment.
786  {
787  auto slice1 = v(seq(last - fix<7>, last - fix<2>));
788  auto slice2 = v(seqN(last - 7, fix<6>));
789  VERIFY_IS_EQUAL(slice1, slice2);
790  VERIFY_IS_EQUAL(int(slice1.SizeAtCompileTime), 6);
791  VERIFY_IS_EQUAL(int(slice2.SizeAtCompileTime), 6);
792  auto slice3 = A(all, seq(fix<0>, last, fix<2>));
793  TEST_SET_BUT_UNUSED_VARIABLE(slice3)
794  VERIFY_IS_EQUAL(int(slice3.RowsAtCompileTime), kRows);
795  VERIFY_IS_EQUAL(int(slice3.ColsAtCompileTime), (kCols + 1) / 2);
796  }
797 
798  // Reverse order.
799  {
800  auto slice = A(all, seq(20, 10, fix<-2>));
801  auto block = Eigen::Map<Eigen::Matrix<double, kRows, Dynamic>, 0, OuterStride<-2 * kRows>>(
802  A.data() + 20 * kRows, A.rows(), (20 - 10 + 2) / 2);
803  VERIFY_IS_EQUAL(slice, block);
804  }
805  {
806  Index n = 10;
807  auto slice1 = A(seqN(last, n, fix<-1>), all);
808  auto slice2 = A(lastN(n).reverse(), all);
809  VERIFY_IS_EQUAL(slice1, slice2);
810  }
811 
812  // Array of indices.
813  {
814  std::vector<int> ind{4, 2, 5, 5, 3};
815  auto slice1 = A(all, ind);
816  for (size_t i = 0; i < ind.size(); ++i) {
817  VERIFY_IS_EQUAL(slice1.col(i), A.col(ind[i]));
818  }
819 
820  auto slice2 = A(all, {4, 2, 5, 5, 3});
821  VERIFY_IS_EQUAL(slice1, slice2);
822 
823  Eigen::ArrayXi indarray(5);
824  indarray << 4, 2, 5, 5, 3;
825  auto slice3 = A(all, indarray);
826  VERIFY_IS_EQUAL(slice1, slice3);
827  }
828 
829  // Custom index list.
830  {
831  struct pad {
832  Index size() const { return out_size; }
833  Index operator[](Index i) const { return std::max<Index>(0, i - (out_size - in_size)); }
834  Index in_size, out_size;
835  };
836 
837  auto slice = A(pad{3, 5}, pad{3, 5});
838  Eigen::MatrixXd B = slice;
839  VERIFY_IS_EQUAL(B.block(2, 2, 3, 3), A.block(0, 0, 3, 3));
840  }
841 }
v
Array< int, Dynamic, 1 > v
Definition: Array_initializer_list_vector_cxx11.cpp:1
EIGEN_UNUSED_VARIABLE
#define EIGEN_UNUSED_VARIABLE(var)
Definition: Macros.h:966
block
m m block(1, 0, 2, 2)<< 4
Eigen::OuterStride
Convenience specialization of Stride to specify only an outer stride See class Map for some examples.
Definition: Stride.h:104
Eigen::Stride
Holds strides information for Map.
Definition: Stride.h:55
m
int * m
Definition: level2_cplx_impl.h:294
TEST_SET_BUT_UNUSED_VARIABLE
#define TEST_SET_BUT_UNUSED_VARIABLE(X)
Definition: main.h:139
Eigen::fix
constexpr internal::FixedInt< N > fix
Definition: IntegralConstant.h:214
pad
Definition: Slicing_custom_padding_cxx11.cpp:1
pad::in_size
Index in_size
Definition: Slicing_custom_padding_cxx11.cpp:4
pad::operator[]
Index operator[](Index i) const
Definition: Slicing_custom_padding_cxx11.cpp:3
pad::out_size
Index out_size
Definition: Slicing_custom_padding_cxx11.cpp:4
pad::size
Index size() const
Definition: Slicing_custom_padding_cxx11.cpp:2

References Eigen::placeholders::all, block(), Eigen::PlainObjectBase< Derived >::cols(), Eigen::PlainObjectBase< Derived >::data(), Eigen::Dynamic, EIGEN_UNUSED_VARIABLE, Eigen::fix, i, pad::in_size, ind, j, Eigen::placeholders::last, Eigen::placeholders::lastN(), m, n, pad::operator[](), pad::out_size, reverse(), Eigen::PlainObjectBase< Derived >::rows(), Eigen::seq(), Eigen::seqN(), pad::size(), TEST_SET_BUT_UNUSED_VARIABLE, v, and VERIFY_IS_EQUAL.

Referenced by EIGEN_DECLARE_TEST().

◆ decode()

test::IndexPair decode ( Index  ij)
26 { return test::IndexPair(ij / 100, ij % 100); }

Referenced by check_indexed_view().

◆ EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST ( indexed_view  )
843  {
844  for (int i = 0; i < g_repeat; i++) {
845  CALL_SUBTEST_1(check_indexed_view());
846  }
847  CALL_SUBTEST_1(check_tutorial_examples());
848 
849  // static checks of some internals:
850  STATIC_CHECK((internal::is_valid_index_type<int>::value));
851  STATIC_CHECK((internal::is_valid_index_type<unsigned int>::value));
852  STATIC_CHECK((internal::is_valid_index_type<short>::value));
853  STATIC_CHECK((internal::is_valid_index_type<std::ptrdiff_t>::value));
854  STATIC_CHECK((internal::is_valid_index_type<std::size_t>::value));
855  STATIC_CHECK((!internal::valid_indexed_view_overload<int, int>::value));
856  STATIC_CHECK((!internal::valid_indexed_view_overload<int, std::ptrdiff_t>::value));
857  STATIC_CHECK((!internal::valid_indexed_view_overload<std::ptrdiff_t, int>::value));
858  STATIC_CHECK((!internal::valid_indexed_view_overload<std::size_t, int>::value));
859 }
check_indexed_view
void check_indexed_view()
Definition: indexed_view.cpp:65
check_tutorial_examples
void check_tutorial_examples()
Definition: indexed_view.cpp:530
Eigen::value
squared absolute value
Definition: GlobalFunctions.h:87
Eigen::g_repeat
static int g_repeat
Definition: main.h:191
CALL_SUBTEST_1
#define CALL_SUBTEST_1(FUNC)
Definition: split_test_helper.h:4

References CALL_SUBTEST_1, check_indexed_view(), check_tutorial_examples(), Eigen::g_repeat, i, STATIC_CHECK, and Eigen::value.

◆ encode()

int encode ( Index  i,
Index  j 
)
24 { return int(i * 100 + j); }

References i, int(), and j.

Referenced by check_indexed_view().

◆ is_same_eq()

template<typename T1 , typename T2 >
std::enable_if_t<internal::is_same<T1, T2>::value, bool> is_same_eq ( const T1 &  a,
const T2 &  b 
)
40  {
41  return (a == b).all();
42 }

References a, and b.

Referenced by check_indexed_view().

◆ is_same_seq()

template<typename T1 , typename T2 >
bool is_same_seq ( const T1 &  a,
const T2 &  b 
)
45  {
46  bool ok = a.first() == b.first() && a.size() == b.size() && Index(a.incrObject()) == Index(b.incrObject());
47  ;
48  if (!ok) {
49  std::cerr << "seqN(" << a.first() << ", " << a.size() << ", " << Index(a.incrObject()) << ") != ";
50  std::cerr << "seqN(" << b.first() << ", " << b.size() << ", " << Index(b.incrObject()) << ")\n";
51  }
52  return ok;
53 }

References a, and b.

Referenced by check_indexed_view(), and is_same_seq_type().

◆ is_same_seq_type()

template<typename T1 , typename T2 >
std::enable_if_t<internal::is_same<T1, T2>::value, bool> is_same_seq_type ( const T1 &  a,
const T2 &  b 
)
56  {
57  return is_same_seq(a, b);
58 }

References a, b, and is_same_seq().

Referenced by check_indexed_view().

◆ match()

template<typename T >
bool match ( const T &  xpr,
std::string  ref,
std::string  str_xpr = "" 
)
29  {
30  EIGEN_UNUSED_VARIABLE(str_xpr);
31  std::stringstream str;
32  str << xpr;
33  if (!(str.str() == ref)) std::cout << str_xpr << "\n" << xpr << "\n\n";
34  return str.str() == ref;
35 }
compute_granudrum_aor.str
str
Definition: compute_granudrum_aor.py:141

References EIGEN_UNUSED_VARIABLE, and compute_granudrum_aor::str.

Referenced by find_pivot(), Eigen::Ref< SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType >::Ref(), Eigen::Ref< SparseVector< MatScalar, MatOptions, MatIndex >, Options, StrideType >::Ref(), and testing::Benchmark::ShouldRun().