[136] | 1 | // This file is part of Eigen, a lightweight C++ template library
|
---|
| 2 | // for linear algebra.
|
---|
| 3 | //
|
---|
| 4 | // Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
|
---|
| 5 | // Copyright (C) 2009 Ricard Marxer <email@ricardmarxer.com>
|
---|
| 6 | //
|
---|
| 7 | // This Source Code Form is subject to the terms of the Mozilla
|
---|
| 8 | // Public License v. 2.0. If a copy of the MPL was not distributed
|
---|
| 9 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
---|
| 10 |
|
---|
| 11 | #include "main.h"
|
---|
| 12 | #include <iostream>
|
---|
| 13 |
|
---|
| 14 | using namespace std;
|
---|
| 15 |
|
---|
| 16 | template<typename MatrixType> void reverse(const MatrixType& m)
|
---|
| 17 | {
|
---|
| 18 | typedef typename MatrixType::Index Index;
|
---|
| 19 | typedef typename MatrixType::Scalar Scalar;
|
---|
| 20 | typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
|
---|
| 21 |
|
---|
| 22 | Index rows = m.rows();
|
---|
| 23 | Index cols = m.cols();
|
---|
| 24 |
|
---|
| 25 | // this test relies a lot on Random.h, and there's not much more that we can do
|
---|
| 26 | // to test it, hence I consider that we will have tested Random.h
|
---|
| 27 | MatrixType m1 = MatrixType::Random(rows, cols);
|
---|
| 28 | VectorType v1 = VectorType::Random(rows);
|
---|
| 29 |
|
---|
| 30 | MatrixType m1_r = m1.reverse();
|
---|
| 31 | // Verify that MatrixBase::reverse() works
|
---|
| 32 | for ( int i = 0; i < rows; i++ ) {
|
---|
| 33 | for ( int j = 0; j < cols; j++ ) {
|
---|
| 34 | VERIFY_IS_APPROX(m1_r(i, j), m1(rows - 1 - i, cols - 1 - j));
|
---|
| 35 | }
|
---|
| 36 | }
|
---|
| 37 |
|
---|
| 38 | Reverse<MatrixType> m1_rd(m1);
|
---|
| 39 | // Verify that a Reverse default (in both directions) of an expression works
|
---|
| 40 | for ( int i = 0; i < rows; i++ ) {
|
---|
| 41 | for ( int j = 0; j < cols; j++ ) {
|
---|
| 42 | VERIFY_IS_APPROX(m1_rd(i, j), m1(rows - 1 - i, cols - 1 - j));
|
---|
| 43 | }
|
---|
| 44 | }
|
---|
| 45 |
|
---|
| 46 | Reverse<MatrixType, BothDirections> m1_rb(m1);
|
---|
| 47 | // Verify that a Reverse in both directions of an expression works
|
---|
| 48 | for ( int i = 0; i < rows; i++ ) {
|
---|
| 49 | for ( int j = 0; j < cols; j++ ) {
|
---|
| 50 | VERIFY_IS_APPROX(m1_rb(i, j), m1(rows - 1 - i, cols - 1 - j));
|
---|
| 51 | }
|
---|
| 52 | }
|
---|
| 53 |
|
---|
| 54 | Reverse<MatrixType, Vertical> m1_rv(m1);
|
---|
| 55 | // Verify that a Reverse in the vertical directions of an expression works
|
---|
| 56 | for ( int i = 0; i < rows; i++ ) {
|
---|
| 57 | for ( int j = 0; j < cols; j++ ) {
|
---|
| 58 | VERIFY_IS_APPROX(m1_rv(i, j), m1(rows - 1 - i, j));
|
---|
| 59 | }
|
---|
| 60 | }
|
---|
| 61 |
|
---|
| 62 | Reverse<MatrixType, Horizontal> m1_rh(m1);
|
---|
| 63 | // Verify that a Reverse in the horizontal directions of an expression works
|
---|
| 64 | for ( int i = 0; i < rows; i++ ) {
|
---|
| 65 | for ( int j = 0; j < cols; j++ ) {
|
---|
| 66 | VERIFY_IS_APPROX(m1_rh(i, j), m1(i, cols - 1 - j));
|
---|
| 67 | }
|
---|
| 68 | }
|
---|
| 69 |
|
---|
| 70 | VectorType v1_r = v1.reverse();
|
---|
| 71 | // Verify that a VectorType::reverse() of an expression works
|
---|
| 72 | for ( int i = 0; i < rows; i++ ) {
|
---|
| 73 | VERIFY_IS_APPROX(v1_r(i), v1(rows - 1 - i));
|
---|
| 74 | }
|
---|
| 75 |
|
---|
| 76 | MatrixType m1_cr = m1.colwise().reverse();
|
---|
| 77 | // Verify that PartialRedux::reverse() works (for colwise())
|
---|
| 78 | for ( int i = 0; i < rows; i++ ) {
|
---|
| 79 | for ( int j = 0; j < cols; j++ ) {
|
---|
| 80 | VERIFY_IS_APPROX(m1_cr(i, j), m1(rows - 1 - i, j));
|
---|
| 81 | }
|
---|
| 82 | }
|
---|
| 83 |
|
---|
| 84 | MatrixType m1_rr = m1.rowwise().reverse();
|
---|
| 85 | // Verify that PartialRedux::reverse() works (for rowwise())
|
---|
| 86 | for ( int i = 0; i < rows; i++ ) {
|
---|
| 87 | for ( int j = 0; j < cols; j++ ) {
|
---|
| 88 | VERIFY_IS_APPROX(m1_rr(i, j), m1(i, cols - 1 - j));
|
---|
| 89 | }
|
---|
| 90 | }
|
---|
| 91 |
|
---|
| 92 | Scalar x = internal::random<Scalar>();
|
---|
| 93 |
|
---|
| 94 | Index r = internal::random<Index>(0, rows-1),
|
---|
| 95 | c = internal::random<Index>(0, cols-1);
|
---|
| 96 |
|
---|
| 97 | m1.reverse()(r, c) = x;
|
---|
| 98 | VERIFY_IS_APPROX(x, m1(rows - 1 - r, cols - 1 - c));
|
---|
| 99 |
|
---|
| 100 | /*
|
---|
| 101 | m1.colwise().reverse()(r, c) = x;
|
---|
| 102 | VERIFY_IS_APPROX(x, m1(rows - 1 - r, c));
|
---|
| 103 |
|
---|
| 104 | m1.rowwise().reverse()(r, c) = x;
|
---|
| 105 | VERIFY_IS_APPROX(x, m1(r, cols - 1 - c));
|
---|
| 106 | */
|
---|
| 107 | }
|
---|
| 108 |
|
---|
| 109 | void test_array_reverse()
|
---|
| 110 | {
|
---|
| 111 | for(int i = 0; i < g_repeat; i++) {
|
---|
| 112 | CALL_SUBTEST_1( reverse(Matrix<float, 1, 1>()) );
|
---|
| 113 | CALL_SUBTEST_2( reverse(Matrix2f()) );
|
---|
| 114 | CALL_SUBTEST_3( reverse(Matrix4f()) );
|
---|
| 115 | CALL_SUBTEST_4( reverse(Matrix4d()) );
|
---|
| 116 | CALL_SUBTEST_5( reverse(MatrixXcf(3, 3)) );
|
---|
| 117 | CALL_SUBTEST_6( reverse(MatrixXi(6, 3)) );
|
---|
| 118 | CALL_SUBTEST_7( reverse(MatrixXcd(20, 20)) );
|
---|
| 119 | CALL_SUBTEST_8( reverse(Matrix<float, 100, 100>()) );
|
---|
| 120 | CALL_SUBTEST_9( reverse(Matrix<float,Dynamic,Dynamic,RowMajor>(6,3)) );
|
---|
| 121 | }
|
---|
| 122 | #ifdef EIGEN_TEST_PART_3
|
---|
| 123 | Vector4f x; x << 1, 2, 3, 4;
|
---|
| 124 | Vector4f y; y << 4, 3, 2, 1;
|
---|
| 125 | VERIFY(x.reverse()[1] == 3);
|
---|
| 126 | VERIFY(x.reverse() == y);
|
---|
| 127 | #endif
|
---|
| 128 | }
|
---|