Gael Guennebaud | cb71dc4 | 2009-01-07 22:20:03 +0000 | [diff] [blame] | 1 | // This file is part of Eigen, a lightweight C++ template library |
Benoit Jacob | 6347b1d | 2009-05-22 20:25:33 +0200 | [diff] [blame] | 2 | // for linear algebra. |
Gael Guennebaud | cb71dc4 | 2009-01-07 22:20:03 +0000 | [diff] [blame] | 3 | // |
Gael Guennebaud | 836da91 | 2015-12-11 10:06:28 +0100 | [diff] [blame] | 4 | // Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr> |
Gael Guennebaud | cb71dc4 | 2009-01-07 22:20:03 +0000 | [diff] [blame] | 5 | // |
Benoit Jacob | 69124cf | 2012-07-13 14:42:47 -0400 | [diff] [blame] | 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/. |
Gael Guennebaud | cb71dc4 | 2009-01-07 22:20:03 +0000 | [diff] [blame] | 9 | |
Gael Guennebaud | e68e165 | 2016-05-24 21:54:03 +0200 | [diff] [blame] | 10 | #ifdef EIGEN_TEST_PART_1 |
| 11 | #define EIGEN_UNALIGNED_VECTORIZE 1 |
| 12 | #endif |
| 13 | |
| 14 | #ifdef EIGEN_TEST_PART_2 |
| 15 | #define EIGEN_UNALIGNED_VECTORIZE 0 |
| 16 | #endif |
| 17 | |
Gael Guennebaud | 836da91 | 2015-12-11 10:06:28 +0100 | [diff] [blame] | 18 | #ifdef EIGEN_DEFAULT_TO_ROW_MAJOR |
| 19 | #undef EIGEN_DEFAULT_TO_ROW_MAJOR |
| 20 | #endif |
Benoit Jacob | 27f5250 | 2010-02-27 19:04:22 -0500 | [diff] [blame] | 21 | #define EIGEN_DEBUG_ASSIGN |
Gael Guennebaud | cb71dc4 | 2009-01-07 22:20:03 +0000 | [diff] [blame] | 22 | #include "main.h" |
| 23 | #include <typeinfo> |
| 24 | |
Gael Guennebaud | 2cf6d30 | 2018-09-20 11:38:19 +0200 | [diff] [blame] | 25 | // Disable "ignoring attributes on template argument" |
| 26 | // for packet_traits<Packet*> |
| 27 | // => The only workaround would be to wrap _m128 and the likes |
| 28 | // within wrappers. |
| 29 | #if EIGEN_GNUC_AT_LEAST(6,0) |
| 30 | #pragma GCC diagnostic ignored "-Wignored-attributes" |
| 31 | #endif |
| 32 | |
Gael Guennebaud | 0fc8954 | 2015-10-27 10:38:49 +0100 | [diff] [blame] | 33 | using internal::demangle_flags; |
| 34 | using internal::demangle_traversal; |
| 35 | using internal::demangle_unrolling; |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 36 | |
Gael Guennebaud | cb71dc4 | 2009-01-07 22:20:03 +0000 | [diff] [blame] | 37 | template<typename Dst, typename Src> |
Benoit Jacob | 94c706d | 2009-11-18 11:57:07 -0500 | [diff] [blame] | 38 | bool test_assign(const Dst&, const Src&, int traversal, int unrolling) |
Gael Guennebaud | cb71dc4 | 2009-01-07 22:20:03 +0000 | [diff] [blame] | 39 | { |
Christoph Hertzberg | e3c8289 | 2018-09-21 21:15:51 +0200 | [diff] [blame] | 40 | EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Dst,Src); |
Gael Guennebaud | 66e99ab | 2016-06-06 15:11:41 +0200 | [diff] [blame] | 41 | typedef internal::copy_using_evaluator_traits<internal::evaluator<Dst>,internal::evaluator<Src>, internal::assign_op<typename Dst::Scalar,typename Src::Scalar> > traits; |
Gael Guennebaud | 512ba0a | 2016-04-13 18:16:35 +0200 | [diff] [blame] | 42 | bool res = traits::Traversal==traversal; |
| 43 | if(unrolling==InnerUnrolling+CompleteUnrolling) |
Gael Guennebaud | a95e1a2 | 2016-04-13 22:00:38 +0200 | [diff] [blame] | 44 | res = res && (int(traits::Unrolling)==InnerUnrolling || int(traits::Unrolling)==CompleteUnrolling); |
Gael Guennebaud | 512ba0a | 2016-04-13 18:16:35 +0200 | [diff] [blame] | 45 | else |
Gael Guennebaud | a95e1a2 | 2016-04-13 22:00:38 +0200 | [diff] [blame] | 46 | res = res && int(traits::Unrolling)==unrolling; |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 47 | if(!res) |
| 48 | { |
Gael Guennebaud | a395024 | 2014-03-12 18:14:58 +0100 | [diff] [blame] | 49 | std::cerr << "Src: " << demangle_flags(Src::Flags) << std::endl; |
Gael Guennebaud | a395024 | 2014-03-12 18:14:58 +0100 | [diff] [blame] | 50 | std::cerr << " " << demangle_flags(internal::evaluator<Src>::Flags) << std::endl; |
Gael Guennebaud | a395024 | 2014-03-12 18:14:58 +0100 | [diff] [blame] | 51 | std::cerr << "Dst: " << demangle_flags(Dst::Flags) << std::endl; |
Gael Guennebaud | a395024 | 2014-03-12 18:14:58 +0100 | [diff] [blame] | 52 | std::cerr << " " << demangle_flags(internal::evaluator<Dst>::Flags) << std::endl; |
Gael Guennebaud | a395024 | 2014-03-12 18:14:58 +0100 | [diff] [blame] | 53 | traits::debug(); |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 54 | std::cerr << " Expected Traversal == " << demangle_traversal(traversal) |
Gael Guennebaud | a395024 | 2014-03-12 18:14:58 +0100 | [diff] [blame] | 55 | << " got " << demangle_traversal(traits::Traversal) << "\n"; |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 56 | std::cerr << " Expected Unrolling == " << demangle_unrolling(unrolling) |
Gael Guennebaud | a395024 | 2014-03-12 18:14:58 +0100 | [diff] [blame] | 57 | << " got " << demangle_unrolling(traits::Unrolling) << "\n"; |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 58 | } |
| 59 | return res; |
Gael Guennebaud | cb71dc4 | 2009-01-07 22:20:03 +0000 | [diff] [blame] | 60 | } |
| 61 | |
Benoit Jacob | b1f666d | 2010-02-26 20:12:51 -0500 | [diff] [blame] | 62 | template<typename Dst, typename Src> |
| 63 | bool test_assign(int traversal, int unrolling) |
| 64 | { |
Christoph Hertzberg | e3c8289 | 2018-09-21 21:15:51 +0200 | [diff] [blame] | 65 | EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Dst,Src); |
Gael Guennebaud | 66e99ab | 2016-06-06 15:11:41 +0200 | [diff] [blame] | 66 | typedef internal::copy_using_evaluator_traits<internal::evaluator<Dst>,internal::evaluator<Src>, internal::assign_op<typename Dst::Scalar,typename Src::Scalar> > traits; |
Gael Guennebaud | a395024 | 2014-03-12 18:14:58 +0100 | [diff] [blame] | 67 | bool res = traits::Traversal==traversal && traits::Unrolling==unrolling; |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 68 | if(!res) |
| 69 | { |
Gael Guennebaud | a395024 | 2014-03-12 18:14:58 +0100 | [diff] [blame] | 70 | std::cerr << "Src: " << demangle_flags(Src::Flags) << std::endl; |
Gael Guennebaud | a395024 | 2014-03-12 18:14:58 +0100 | [diff] [blame] | 71 | std::cerr << " " << demangle_flags(internal::evaluator<Src>::Flags) << std::endl; |
Gael Guennebaud | a395024 | 2014-03-12 18:14:58 +0100 | [diff] [blame] | 72 | std::cerr << "Dst: " << demangle_flags(Dst::Flags) << std::endl; |
Gael Guennebaud | a395024 | 2014-03-12 18:14:58 +0100 | [diff] [blame] | 73 | std::cerr << " " << demangle_flags(internal::evaluator<Dst>::Flags) << std::endl; |
Gael Guennebaud | a395024 | 2014-03-12 18:14:58 +0100 | [diff] [blame] | 74 | traits::debug(); |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 75 | std::cerr << " Expected Traversal == " << demangle_traversal(traversal) |
Gael Guennebaud | a395024 | 2014-03-12 18:14:58 +0100 | [diff] [blame] | 76 | << " got " << demangle_traversal(traits::Traversal) << "\n"; |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 77 | std::cerr << " Expected Unrolling == " << demangle_unrolling(unrolling) |
Gael Guennebaud | a395024 | 2014-03-12 18:14:58 +0100 | [diff] [blame] | 78 | << " got " << demangle_unrolling(traits::Unrolling) << "\n"; |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 79 | } |
| 80 | return res; |
Benoit Jacob | b1f666d | 2010-02-26 20:12:51 -0500 | [diff] [blame] | 81 | } |
| 82 | |
Gael Guennebaud | cb71dc4 | 2009-01-07 22:20:03 +0000 | [diff] [blame] | 83 | template<typename Xpr> |
Benoit Jacob | 94c706d | 2009-11-18 11:57:07 -0500 | [diff] [blame] | 84 | bool test_redux(const Xpr&, int traversal, int unrolling) |
Gael Guennebaud | cb71dc4 | 2009-01-07 22:20:03 +0000 | [diff] [blame] | 85 | { |
Gael Guennebaud | 66e99ab | 2016-06-06 15:11:41 +0200 | [diff] [blame] | 86 | typedef typename Xpr::Scalar Scalar; |
| 87 | typedef internal::redux_traits<internal::scalar_sum_op<Scalar,Scalar>,internal::redux_evaluator<Xpr> > traits; |
Gael Guennebaud | a395024 | 2014-03-12 18:14:58 +0100 | [diff] [blame] | 88 | |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 89 | bool res = traits::Traversal==traversal && traits::Unrolling==unrolling; |
| 90 | if(!res) |
| 91 | { |
Gael Guennebaud | a395024 | 2014-03-12 18:14:58 +0100 | [diff] [blame] | 92 | std::cerr << demangle_flags(Xpr::Flags) << std::endl; |
Gael Guennebaud | a395024 | 2014-03-12 18:14:58 +0100 | [diff] [blame] | 93 | std::cerr << demangle_flags(internal::evaluator<Xpr>::Flags) << std::endl; |
Gael Guennebaud | a395024 | 2014-03-12 18:14:58 +0100 | [diff] [blame] | 94 | traits::debug(); |
| 95 | |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 96 | std::cerr << " Expected Traversal == " << demangle_traversal(traversal) |
| 97 | << " got " << demangle_traversal(traits::Traversal) << "\n"; |
| 98 | std::cerr << " Expected Unrolling == " << demangle_unrolling(unrolling) |
| 99 | << " got " << demangle_unrolling(traits::Unrolling) << "\n"; |
| 100 | } |
| 101 | return res; |
Gael Guennebaud | cb71dc4 | 2009-01-07 22:20:03 +0000 | [diff] [blame] | 102 | } |
| 103 | |
Gael Guennebaud | febcce3 | 2015-08-07 20:05:31 +0200 | [diff] [blame] | 104 | template<typename Scalar, bool Enable = internal::packet_traits<Scalar>::Vectorizable> |
| 105 | struct vectorization_logic |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 106 | { |
Christoph Hertzberg | 4f440b8 | 2014-07-14 14:36:20 +0200 | [diff] [blame] | 107 | typedef internal::packet_traits<Scalar> PacketTraits; |
Gael Guennebaud | febcce3 | 2015-08-07 20:05:31 +0200 | [diff] [blame] | 108 | |
| 109 | typedef typename internal::packet_traits<Scalar>::type PacketType; |
| 110 | typedef typename internal::unpacket_traits<PacketType>::half HalfPacketType; |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 111 | enum { |
Gael Guennebaud | febcce3 | 2015-08-07 20:05:31 +0200 | [diff] [blame] | 112 | PacketSize = internal::unpacket_traits<PacketType>::size, |
| 113 | HalfPacketSize = internal::unpacket_traits<HalfPacketType>::size |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 114 | }; |
| 115 | static void run() |
| 116 | { |
| 117 | |
| 118 | typedef Matrix<Scalar,PacketSize,1> Vector1; |
| 119 | typedef Matrix<Scalar,Dynamic,1> VectorX; |
| 120 | typedef Matrix<Scalar,Dynamic,Dynamic> MatrixXX; |
| 121 | typedef Matrix<Scalar,PacketSize,PacketSize> Matrix11; |
Gael Guennebaud | 91716f0 | 2018-09-21 14:32:24 +0200 | [diff] [blame] | 122 | typedef Matrix<Scalar,(Matrix11::Flags&RowMajorBit)?8:2*PacketSize,(Matrix11::Flags&RowMajorBit)?2*PacketSize:8> Matrix22; |
Gael Guennebaud | 64356a6 | 2011-01-04 14:18:07 +0100 | [diff] [blame] | 123 | typedef Matrix<Scalar,(Matrix11::Flags&RowMajorBit)?16:4*PacketSize,(Matrix11::Flags&RowMajorBit)?4*PacketSize:16> Matrix44; |
| 124 | typedef Matrix<Scalar,(Matrix11::Flags&RowMajorBit)?16:4*PacketSize,(Matrix11::Flags&RowMajorBit)?4*PacketSize:16,DontAlign|EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION> Matrix44u; |
Gael Guennebaud | 2606abe | 2014-04-18 21:14:40 +0200 | [diff] [blame] | 125 | typedef Matrix<Scalar,4*PacketSize,4*PacketSize,ColMajor> Matrix44c; |
| 126 | typedef Matrix<Scalar,4*PacketSize,4*PacketSize,RowMajor> Matrix44r; |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 127 | |
| 128 | typedef Matrix<Scalar, |
Gael Guennebaud | 91716f0 | 2018-09-21 14:32:24 +0200 | [diff] [blame] | 129 | (PacketSize==16 ? 8 : PacketSize==8 ? 4 : PacketSize==4 ? 2 : PacketSize==2 ? 1 : /*PacketSize==1 ?*/ 1), |
| 130 | (PacketSize==16 ? 2 : PacketSize==8 ? 2 : PacketSize==4 ? 2 : PacketSize==2 ? 2 : /*PacketSize==1 ?*/ 1) |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 131 | > Matrix1; |
| 132 | |
| 133 | typedef Matrix<Scalar, |
Gael Guennebaud | 91716f0 | 2018-09-21 14:32:24 +0200 | [diff] [blame] | 134 | (PacketSize==16 ? 8 : PacketSize==8 ? 4 : PacketSize==4 ? 2 : PacketSize==2 ? 1 : /*PacketSize==1 ?*/ 1), |
| 135 | (PacketSize==16 ? 2 : PacketSize==8 ? 2 : PacketSize==4 ? 2 : PacketSize==2 ? 2 : /*PacketSize==1 ?*/ 1), |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 136 | DontAlign|((Matrix1::Flags&RowMajorBit)?RowMajor:ColMajor)> Matrix1u; |
| 137 | |
Gael Guennebaud | 64356a6 | 2011-01-04 14:18:07 +0100 | [diff] [blame] | 138 | // this type is made such that it can only be vectorized when viewed as a linear 1D vector |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 139 | typedef Matrix<Scalar, |
Gael Guennebaud | 91716f0 | 2018-09-21 14:32:24 +0200 | [diff] [blame] | 140 | (PacketSize==16 ? 4 : PacketSize==8 ? 4 : PacketSize==4 ? 6 : PacketSize==2 ? ((Matrix11::Flags&RowMajorBit)?2:3) : /*PacketSize==1 ?*/ 1), |
| 141 | (PacketSize==16 ? 12 : PacketSize==8 ? 6 : PacketSize==4 ? 2 : PacketSize==2 ? ((Matrix11::Flags&RowMajorBit)?3:2) : /*PacketSize==1 ?*/ 3) |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 142 | > Matrix3; |
Gael Guennebaud | 501bc60 | 2011-05-19 21:52:40 +0200 | [diff] [blame] | 143 | |
| 144 | #if !EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 145 | VERIFY(test_assign(Vector1(),Vector1(), |
| 146 | InnerVectorizedTraversal,CompleteUnrolling)); |
| 147 | VERIFY(test_assign(Vector1(),Vector1()+Vector1(), |
| 148 | InnerVectorizedTraversal,CompleteUnrolling)); |
| 149 | VERIFY(test_assign(Vector1(),Vector1().cwiseProduct(Vector1()), |
| 150 | InnerVectorizedTraversal,CompleteUnrolling)); |
| 151 | VERIFY(test_assign(Vector1(),Vector1().template cast<Scalar>(), |
| 152 | InnerVectorizedTraversal,CompleteUnrolling)); |
| 153 | |
| 154 | |
| 155 | VERIFY(test_assign(Vector1(),Vector1(), |
| 156 | InnerVectorizedTraversal,CompleteUnrolling)); |
| 157 | VERIFY(test_assign(Vector1(),Vector1()+Vector1(), |
| 158 | InnerVectorizedTraversal,CompleteUnrolling)); |
| 159 | VERIFY(test_assign(Vector1(),Vector1().cwiseProduct(Vector1()), |
| 160 | InnerVectorizedTraversal,CompleteUnrolling)); |
| 161 | |
| 162 | VERIFY(test_assign(Matrix44(),Matrix44()+Matrix44(), |
| 163 | InnerVectorizedTraversal,InnerUnrolling)); |
| 164 | |
| 165 | VERIFY(test_assign(Matrix44u(),Matrix44()+Matrix44(), |
Gael Guennebaud | e68e165 | 2016-05-24 21:54:03 +0200 | [diff] [blame] | 166 | EIGEN_UNALIGNED_VECTORIZE ? InnerVectorizedTraversal : LinearTraversal, |
| 167 | EIGEN_UNALIGNED_VECTORIZE ? InnerUnrolling : NoUnrolling)); |
| 168 | |
| 169 | VERIFY(test_assign(Matrix1(),Matrix1()+Matrix1(), |
| 170 | (Matrix1::InnerSizeAtCompileTime % PacketSize)==0 ? InnerVectorizedTraversal : LinearVectorizedTraversal, |
| 171 | CompleteUnrolling)); |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 172 | |
| 173 | VERIFY(test_assign(Matrix1u(),Matrix1()+Matrix1(), |
Gael Guennebaud | e68e165 | 2016-05-24 21:54:03 +0200 | [diff] [blame] | 174 | EIGEN_UNALIGNED_VECTORIZE ? ((Matrix1::InnerSizeAtCompileTime % PacketSize)==0 ? InnerVectorizedTraversal : LinearVectorizedTraversal) |
| 175 | : LinearTraversal, CompleteUnrolling)); |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 176 | |
Gael Guennebaud | aa2b46a | 2010-07-23 16:29:29 +0200 | [diff] [blame] | 177 | VERIFY(test_assign(Matrix44c().col(1),Matrix44c().col(2)+Matrix44c().col(3), |
| 178 | InnerVectorizedTraversal,CompleteUnrolling)); |
Benoit Steiner | 25d05c4 | 2016-04-12 14:13:25 -0700 | [diff] [blame] | 179 | |
Gael Guennebaud | aa2b46a | 2010-07-23 16:29:29 +0200 | [diff] [blame] | 180 | VERIFY(test_assign(Matrix44r().row(2),Matrix44r().row(1)+Matrix44r().row(1), |
| 181 | InnerVectorizedTraversal,CompleteUnrolling)); |
Benoit Steiner | 25d05c4 | 2016-04-12 14:13:25 -0700 | [diff] [blame] | 182 | |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 183 | if(PacketSize>1) |
| 184 | { |
Gael Guennebaud | aa2b46a | 2010-07-23 16:29:29 +0200 | [diff] [blame] | 185 | typedef Matrix<Scalar,3,3,ColMajor> Matrix33c; |
Gael Guennebaud | e68e165 | 2016-05-24 21:54:03 +0200 | [diff] [blame] | 186 | typedef Matrix<Scalar,3,1,ColMajor> Vector3; |
Gael Guennebaud | aa2b46a | 2010-07-23 16:29:29 +0200 | [diff] [blame] | 187 | VERIFY(test_assign(Matrix33c().row(2),Matrix33c().row(1)+Matrix33c().row(1), |
| 188 | LinearTraversal,CompleteUnrolling)); |
Gael Guennebaud | e68e165 | 2016-05-24 21:54:03 +0200 | [diff] [blame] | 189 | VERIFY(test_assign(Vector3(),Vector3()+Vector3(), |
Gael Guennebaud | aab749b | 2018-12-06 16:55:00 +0100 | [diff] [blame^] | 190 | sizeof(Scalar)==16 ? InnerVectorizedTraversal : (EIGEN_UNALIGNED_VECTORIZE ? LinearVectorizedTraversal : LinearTraversal), CompleteUnrolling)); |
Gael Guennebaud | aa2b46a | 2010-07-23 16:29:29 +0200 | [diff] [blame] | 191 | VERIFY(test_assign(Matrix33c().col(0),Matrix33c().col(1)+Matrix33c().col(1), |
Gael Guennebaud | aab749b | 2018-12-06 16:55:00 +0100 | [diff] [blame^] | 192 | EIGEN_UNALIGNED_VECTORIZE ? (sizeof(Scalar)==16 ? InnerVectorizedTraversal : LinearVectorizedTraversal) |
| 193 | : (sizeof(Scalar)==16 ? SliceVectorizedTraversal : LinearTraversal), |
| 194 | ((!EIGEN_UNALIGNED_VECTORIZE) && (sizeof(Scalar)==16)) ? NoUnrolling : CompleteUnrolling)); |
Benoit Steiner | 25d05c4 | 2016-04-12 14:13:25 -0700 | [diff] [blame] | 195 | |
| 196 | VERIFY(test_assign(Matrix3(),Matrix3().cwiseProduct(Matrix3()), |
| 197 | LinearVectorizedTraversal,CompleteUnrolling)); |
| 198 | |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 199 | VERIFY(test_assign(Matrix<Scalar,17,17>(),Matrix<Scalar,17,17>()+Matrix<Scalar,17,17>(), |
Gael Guennebaud | aab749b | 2018-12-06 16:55:00 +0100 | [diff] [blame^] | 200 | sizeof(Scalar)==16 ? InnerVectorizedTraversal : |
Gael Guennebaud | e68e165 | 2016-05-24 21:54:03 +0200 | [diff] [blame] | 201 | EIGEN_UNALIGNED_VECTORIZE ? LinearVectorizedTraversal : |
Gael Guennebaud | aab749b | 2018-12-06 16:55:00 +0100 | [diff] [blame^] | 202 | LinearTraversal, |
Gael Guennebaud | e68e165 | 2016-05-24 21:54:03 +0200 | [diff] [blame] | 203 | NoUnrolling)); |
| 204 | |
| 205 | VERIFY(test_assign(Matrix11(), Matrix11()+Matrix11(),InnerVectorizedTraversal,CompleteUnrolling)); |
| 206 | |
Benoit Steiner | 25d05c4 | 2016-04-12 14:13:25 -0700 | [diff] [blame] | 207 | |
Gael Guennebaud | 91716f0 | 2018-09-21 14:32:24 +0200 | [diff] [blame] | 208 | VERIFY(test_assign(Matrix11(),Matrix<Scalar,21,21>().template block<PacketSize,PacketSize>(2,3)+Matrix<Scalar,21,21>().template block<PacketSize,PacketSize>(3,2), |
Gael Guennebaud | 5ca2457 | 2016-07-06 22:25:24 +0200 | [diff] [blame] | 209 | (EIGEN_UNALIGNED_VECTORIZE) ? InnerVectorizedTraversal : DefaultTraversal, CompleteUnrolling|InnerUnrolling)); |
Gael Guennebaud | 512ba0a | 2016-04-13 18:16:35 +0200 | [diff] [blame] | 210 | |
| 211 | VERIFY(test_assign(Vector1(),Matrix11()*Vector1(), |
| 212 | InnerVectorizedTraversal,CompleteUnrolling)); |
| 213 | |
| 214 | VERIFY(test_assign(Matrix11(),Matrix11().lazyProduct(Matrix11()), |
| 215 | InnerVectorizedTraversal,InnerUnrolling+CompleteUnrolling)); |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 216 | } |
Benoit Steiner | 25d05c4 | 2016-04-12 14:13:25 -0700 | [diff] [blame] | 217 | |
Gael Guennebaud | 512ba0a | 2016-04-13 18:16:35 +0200 | [diff] [blame] | 218 | VERIFY(test_redux(Vector1(), |
| 219 | LinearVectorizedTraversal,CompleteUnrolling)); |
| 220 | |
Gael Guennebaud | 9c3aed9 | 2017-12-14 14:24:33 +0100 | [diff] [blame] | 221 | VERIFY(test_redux(Vector1().array()*Vector1().array(), |
| 222 | LinearVectorizedTraversal,CompleteUnrolling)); |
| 223 | |
| 224 | VERIFY(test_redux((Vector1().array()*Vector1().array()).col(0), |
| 225 | LinearVectorizedTraversal,CompleteUnrolling)); |
| 226 | |
Gael Guennebaud | 512ba0a | 2016-04-13 18:16:35 +0200 | [diff] [blame] | 227 | VERIFY(test_redux(Matrix<Scalar,PacketSize,3>(), |
| 228 | LinearVectorizedTraversal,CompleteUnrolling)); |
| 229 | |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 230 | VERIFY(test_redux(Matrix3(), |
| 231 | LinearVectorizedTraversal,CompleteUnrolling)); |
| 232 | |
| 233 | VERIFY(test_redux(Matrix44(), |
| 234 | LinearVectorizedTraversal,NoUnrolling)); |
| 235 | |
Gael Guennebaud | b00e48a | 2018-09-21 13:45:56 +0200 | [diff] [blame] | 236 | if(PacketSize>1) { |
| 237 | VERIFY(test_redux(Matrix44().template block<(Matrix1::Flags&RowMajorBit)?4:PacketSize,(Matrix1::Flags&RowMajorBit)?PacketSize:4>(1,2), |
| 238 | SliceVectorizedTraversal,CompleteUnrolling)); |
| 239 | |
| 240 | VERIFY(test_redux(Matrix44().template block<(Matrix1::Flags&RowMajorBit)?2:PacketSize,(Matrix1::Flags&RowMajorBit)?PacketSize:2>(1,2), |
| 241 | DefaultTraversal,CompleteUnrolling)); |
| 242 | } |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 243 | |
| 244 | VERIFY(test_redux(Matrix44c().template block<2*PacketSize,1>(1,2), |
| 245 | LinearVectorizedTraversal,CompleteUnrolling)); |
| 246 | |
| 247 | VERIFY(test_redux(Matrix44r().template block<1,2*PacketSize>(2,1), |
| 248 | LinearVectorizedTraversal,CompleteUnrolling)); |
Gael Guennebaud | 2606abe | 2014-04-18 21:14:40 +0200 | [diff] [blame] | 249 | |
Gael Guennebaud | 501bc60 | 2011-05-19 21:52:40 +0200 | [diff] [blame] | 250 | VERIFY((test_assign< |
Gael Guennebaud | 1f50243 | 2015-08-06 15:31:07 +0200 | [diff] [blame] | 251 | Map<Matrix22, AlignedMax, OuterStride<3*PacketSize> >, |
Gael Guennebaud | 501bc60 | 2011-05-19 21:52:40 +0200 | [diff] [blame] | 252 | Matrix22 |
| 253 | >(InnerVectorizedTraversal,CompleteUnrolling))); |
| 254 | |
| 255 | VERIFY((test_assign< |
Gael Guennebaud | 1f50243 | 2015-08-06 15:31:07 +0200 | [diff] [blame] | 256 | Map<Matrix<Scalar,EIGEN_PLAIN_ENUM_MAX(2,PacketSize),EIGEN_PLAIN_ENUM_MAX(2,PacketSize)>, AlignedMax, InnerStride<3*PacketSize> >, |
Gael Guennebaud | 2606abe | 2014-04-18 21:14:40 +0200 | [diff] [blame] | 257 | Matrix<Scalar,EIGEN_PLAIN_ENUM_MAX(2,PacketSize),EIGEN_PLAIN_ENUM_MAX(2,PacketSize)> |
Gael Guennebaud | 5ca2457 | 2016-07-06 22:25:24 +0200 | [diff] [blame] | 258 | >(DefaultTraversal,PacketSize>=8?InnerUnrolling:CompleteUnrolling))); |
Gael Guennebaud | 501bc60 | 2011-05-19 21:52:40 +0200 | [diff] [blame] | 259 | |
Gael Guennebaud | 2606abe | 2014-04-18 21:14:40 +0200 | [diff] [blame] | 260 | VERIFY((test_assign(Matrix11(), Matrix<Scalar,PacketSize,EIGEN_PLAIN_ENUM_MIN(2,PacketSize)>()*Matrix<Scalar,EIGEN_PLAIN_ENUM_MIN(2,PacketSize),PacketSize>(), |
Gael Guennebaud | 1330f8b | 2015-03-13 21:15:50 +0100 | [diff] [blame] | 261 | InnerVectorizedTraversal, CompleteUnrolling))); |
Gael Guennebaud | 501bc60 | 2011-05-19 21:52:40 +0200 | [diff] [blame] | 262 | #endif |
| 263 | |
| 264 | VERIFY(test_assign(MatrixXX(10,10),MatrixXX(20,20).block(10,10,2,3), |
| 265 | SliceVectorizedTraversal,NoUnrolling)); |
| 266 | |
| 267 | VERIFY(test_redux(VectorX(10), |
| 268 | LinearVectorizedTraversal,NoUnrolling)); |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 269 | } |
| 270 | }; |
| 271 | |
| 272 | template<typename Scalar> struct vectorization_logic<Scalar,false> |
| 273 | { |
| 274 | static void run() {} |
| 275 | }; |
| 276 | |
Gael Guennebaud | febcce3 | 2015-08-07 20:05:31 +0200 | [diff] [blame] | 277 | template<typename Scalar, bool Enable = !internal::is_same<typename internal::unpacket_traits<typename internal::packet_traits<Scalar>::type>::half, |
| 278 | typename internal::packet_traits<Scalar>::type>::value > |
| 279 | struct vectorization_logic_half |
| 280 | { |
| 281 | typedef internal::packet_traits<Scalar> PacketTraits; |
| 282 | typedef typename internal::unpacket_traits<typename internal::packet_traits<Scalar>::type>::half PacketType; |
| 283 | enum { |
| 284 | PacketSize = internal::unpacket_traits<PacketType>::size |
| 285 | }; |
| 286 | static void run() |
| 287 | { |
| 288 | |
| 289 | typedef Matrix<Scalar,PacketSize,1> Vector1; |
| 290 | typedef Matrix<Scalar,PacketSize,PacketSize> Matrix11; |
| 291 | typedef Matrix<Scalar,5*PacketSize,7,ColMajor> Matrix57; |
Gael Guennebaud | 512ba0a | 2016-04-13 18:16:35 +0200 | [diff] [blame] | 292 | typedef Matrix<Scalar,3*PacketSize,5,ColMajor> Matrix35; |
Gael Guennebaud | febcce3 | 2015-08-07 20:05:31 +0200 | [diff] [blame] | 293 | typedef Matrix<Scalar,5*PacketSize,7,DontAlign|ColMajor> Matrix57u; |
Gael Guennebaud | febcce3 | 2015-08-07 20:05:31 +0200 | [diff] [blame] | 294 | |
| 295 | typedef Matrix<Scalar, |
Gael Guennebaud | 91716f0 | 2018-09-21 14:32:24 +0200 | [diff] [blame] | 296 | (PacketSize==16 ? 8 : PacketSize==8 ? 4 : PacketSize==4 ? 2 : PacketSize==2 ? 1 : /*PacketSize==1 ?*/ 1), |
| 297 | (PacketSize==16 ? 2 : PacketSize==8 ? 2 : PacketSize==4 ? 2 : PacketSize==2 ? 2 : /*PacketSize==1 ?*/ 1) |
Gael Guennebaud | febcce3 | 2015-08-07 20:05:31 +0200 | [diff] [blame] | 298 | > Matrix1; |
| 299 | |
| 300 | typedef Matrix<Scalar, |
Gael Guennebaud | 91716f0 | 2018-09-21 14:32:24 +0200 | [diff] [blame] | 301 | (PacketSize==16 ? 8 : PacketSize==8 ? 4 : PacketSize==4 ? 2 : PacketSize==2 ? 1 : /*PacketSize==1 ?*/ 1), |
| 302 | (PacketSize==16 ? 2 : PacketSize==8 ? 2 : PacketSize==4 ? 2 : PacketSize==2 ? 2 : /*PacketSize==1 ?*/ 1), |
Gael Guennebaud | febcce3 | 2015-08-07 20:05:31 +0200 | [diff] [blame] | 303 | DontAlign|((Matrix1::Flags&RowMajorBit)?RowMajor:ColMajor)> Matrix1u; |
| 304 | |
| 305 | // this type is made such that it can only be vectorized when viewed as a linear 1D vector |
| 306 | typedef Matrix<Scalar, |
Gael Guennebaud | 91716f0 | 2018-09-21 14:32:24 +0200 | [diff] [blame] | 307 | (PacketSize==16 ? 4 : PacketSize==8 ? 4 : PacketSize==4 ? 6 : PacketSize==2 ? ((Matrix11::Flags&RowMajorBit)?2:3) : /*PacketSize==1 ?*/ 1), |
| 308 | (PacketSize==16 ? 12 : PacketSize==8 ? 6 : PacketSize==4 ? 2 : PacketSize==2 ? ((Matrix11::Flags&RowMajorBit)?3:2) : /*PacketSize==1 ?*/ 3) |
Gael Guennebaud | febcce3 | 2015-08-07 20:05:31 +0200 | [diff] [blame] | 309 | > Matrix3; |
| 310 | |
| 311 | #if !EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT |
| 312 | VERIFY(test_assign(Vector1(),Vector1(), |
| 313 | InnerVectorizedTraversal,CompleteUnrolling)); |
| 314 | VERIFY(test_assign(Vector1(),Vector1()+Vector1(), |
| 315 | InnerVectorizedTraversal,CompleteUnrolling)); |
Gael Guennebaud | e68e165 | 2016-05-24 21:54:03 +0200 | [diff] [blame] | 316 | VERIFY(test_assign(Vector1(),Vector1().template segment<PacketSize>(0).derived(), |
| 317 | EIGEN_UNALIGNED_VECTORIZE ? InnerVectorizedTraversal : LinearVectorizedTraversal,CompleteUnrolling)); |
| 318 | VERIFY(test_assign(Vector1(),Scalar(2.1)*Vector1()-Vector1(), |
| 319 | InnerVectorizedTraversal,CompleteUnrolling)); |
| 320 | VERIFY(test_assign(Vector1(),(Scalar(2.1)*Vector1().template segment<PacketSize>(0)-Vector1().template segment<PacketSize>(0)).derived(), |
| 321 | EIGEN_UNALIGNED_VECTORIZE ? InnerVectorizedTraversal : LinearVectorizedTraversal,CompleteUnrolling)); |
Gael Guennebaud | febcce3 | 2015-08-07 20:05:31 +0200 | [diff] [blame] | 322 | VERIFY(test_assign(Vector1(),Vector1().cwiseProduct(Vector1()), |
| 323 | InnerVectorizedTraversal,CompleteUnrolling)); |
| 324 | VERIFY(test_assign(Vector1(),Vector1().template cast<Scalar>(), |
| 325 | InnerVectorizedTraversal,CompleteUnrolling)); |
| 326 | |
| 327 | |
| 328 | VERIFY(test_assign(Vector1(),Vector1(), |
| 329 | InnerVectorizedTraversal,CompleteUnrolling)); |
| 330 | VERIFY(test_assign(Vector1(),Vector1()+Vector1(), |
| 331 | InnerVectorizedTraversal,CompleteUnrolling)); |
| 332 | VERIFY(test_assign(Vector1(),Vector1().cwiseProduct(Vector1()), |
| 333 | InnerVectorizedTraversal,CompleteUnrolling)); |
| 334 | |
| 335 | VERIFY(test_assign(Matrix57(),Matrix57()+Matrix57(), |
| 336 | InnerVectorizedTraversal,InnerUnrolling)); |
| 337 | |
| 338 | VERIFY(test_assign(Matrix57u(),Matrix57()+Matrix57(), |
Gael Guennebaud | e68e165 | 2016-05-24 21:54:03 +0200 | [diff] [blame] | 339 | EIGEN_UNALIGNED_VECTORIZE ? InnerVectorizedTraversal : LinearTraversal, |
| 340 | EIGEN_UNALIGNED_VECTORIZE ? InnerUnrolling : NoUnrolling)); |
Gael Guennebaud | febcce3 | 2015-08-07 20:05:31 +0200 | [diff] [blame] | 341 | |
| 342 | VERIFY(test_assign(Matrix1u(),Matrix1()+Matrix1(), |
Gael Guennebaud | e68e165 | 2016-05-24 21:54:03 +0200 | [diff] [blame] | 343 | EIGEN_UNALIGNED_VECTORIZE ? ((Matrix1::InnerSizeAtCompileTime % PacketSize)==0 ? InnerVectorizedTraversal : LinearVectorizedTraversal) : LinearTraversal,CompleteUnrolling)); |
Gael Guennebaud | febcce3 | 2015-08-07 20:05:31 +0200 | [diff] [blame] | 344 | |
| 345 | if(PacketSize>1) |
| 346 | { |
| 347 | typedef Matrix<Scalar,3,3,ColMajor> Matrix33c; |
| 348 | VERIFY(test_assign(Matrix33c().row(2),Matrix33c().row(1)+Matrix33c().row(1), |
| 349 | LinearTraversal,CompleteUnrolling)); |
| 350 | VERIFY(test_assign(Matrix33c().col(0),Matrix33c().col(1)+Matrix33c().col(1), |
Gael Guennebaud | aab749b | 2018-12-06 16:55:00 +0100 | [diff] [blame^] | 351 | EIGEN_UNALIGNED_VECTORIZE ? (sizeof(Scalar)==16 ? InnerVectorizedTraversal : LinearVectorizedTraversal) |
| 352 | : (sizeof(Scalar)==16 ? SliceVectorizedTraversal : LinearTraversal), |
| 353 | ((!EIGEN_UNALIGNED_VECTORIZE) && (sizeof(Scalar)==16)) ? NoUnrolling : CompleteUnrolling)); |
Gael Guennebaud | febcce3 | 2015-08-07 20:05:31 +0200 | [diff] [blame] | 354 | |
| 355 | VERIFY(test_assign(Matrix3(),Matrix3().cwiseQuotient(Matrix3()), |
| 356 | PacketTraits::HasDiv ? LinearVectorizedTraversal : LinearTraversal,CompleteUnrolling)); |
| 357 | |
| 358 | VERIFY(test_assign(Matrix<Scalar,17,17>(),Matrix<Scalar,17,17>()+Matrix<Scalar,17,17>(), |
Gael Guennebaud | aab749b | 2018-12-06 16:55:00 +0100 | [diff] [blame^] | 359 | sizeof(Scalar)==16 ? InnerVectorizedTraversal : (EIGEN_UNALIGNED_VECTORIZE ? LinearVectorizedTraversal : LinearTraversal), |
Gael Guennebaud | e68e165 | 2016-05-24 21:54:03 +0200 | [diff] [blame] | 360 | NoUnrolling)); |
Gael Guennebaud | febcce3 | 2015-08-07 20:05:31 +0200 | [diff] [blame] | 361 | |
| 362 | VERIFY(test_assign(Matrix11(),Matrix<Scalar,17,17>().template block<PacketSize,PacketSize>(2,3)+Matrix<Scalar,17,17>().template block<PacketSize,PacketSize>(8,4), |
Gael Guennebaud | 91716f0 | 2018-09-21 14:32:24 +0200 | [diff] [blame] | 363 | EIGEN_UNALIGNED_VECTORIZE ? InnerVectorizedTraversal : DefaultTraversal,InnerUnrolling+CompleteUnrolling)); |
| 364 | |
Gael Guennebaud | 512ba0a | 2016-04-13 18:16:35 +0200 | [diff] [blame] | 365 | |
| 366 | VERIFY(test_assign(Vector1(),Matrix11()*Vector1(), |
| 367 | InnerVectorizedTraversal,CompleteUnrolling)); |
| 368 | |
| 369 | VERIFY(test_assign(Matrix11(),Matrix11().lazyProduct(Matrix11()), |
| 370 | InnerVectorizedTraversal,InnerUnrolling+CompleteUnrolling)); |
Gael Guennebaud | febcce3 | 2015-08-07 20:05:31 +0200 | [diff] [blame] | 371 | } |
| 372 | |
Gael Guennebaud | 512ba0a | 2016-04-13 18:16:35 +0200 | [diff] [blame] | 373 | VERIFY(test_redux(Vector1(), |
| 374 | LinearVectorizedTraversal,CompleteUnrolling)); |
| 375 | |
| 376 | VERIFY(test_redux(Matrix<Scalar,PacketSize,3>(), |
| 377 | LinearVectorizedTraversal,CompleteUnrolling)); |
| 378 | |
Gael Guennebaud | febcce3 | 2015-08-07 20:05:31 +0200 | [diff] [blame] | 379 | VERIFY(test_redux(Matrix3(), |
| 380 | LinearVectorizedTraversal,CompleteUnrolling)); |
| 381 | |
Gael Guennebaud | 512ba0a | 2016-04-13 18:16:35 +0200 | [diff] [blame] | 382 | VERIFY(test_redux(Matrix35(), |
Gael Guennebaud | febcce3 | 2015-08-07 20:05:31 +0200 | [diff] [blame] | 383 | LinearVectorizedTraversal,CompleteUnrolling)); |
| 384 | |
Gael Guennebaud | b00e48a | 2018-09-21 13:45:56 +0200 | [diff] [blame] | 385 | VERIFY(test_redux(Matrix57().template block<PacketSize==1?2:PacketSize,3>(1,0), |
| 386 | SliceVectorizedTraversal,CompleteUnrolling)); |
| 387 | |
| 388 | if(PacketSize>1) { |
| 389 | VERIFY(test_redux(Matrix57().template block<PacketSize,2>(1,0), |
| 390 | DefaultTraversal,CompleteUnrolling)); |
| 391 | } |
Gael Guennebaud | febcce3 | 2015-08-07 20:05:31 +0200 | [diff] [blame] | 392 | |
| 393 | VERIFY((test_assign< |
| 394 | Map<Matrix<Scalar,EIGEN_PLAIN_ENUM_MAX(2,PacketSize),EIGEN_PLAIN_ENUM_MAX(2,PacketSize)>, AlignedMax, InnerStride<3*PacketSize> >, |
| 395 | Matrix<Scalar,EIGEN_PLAIN_ENUM_MAX(2,PacketSize),EIGEN_PLAIN_ENUM_MAX(2,PacketSize)> |
Gael Guennebaud | 91716f0 | 2018-09-21 14:32:24 +0200 | [diff] [blame] | 396 | >(DefaultTraversal,PacketSize>4?InnerUnrolling:CompleteUnrolling))); |
Gael Guennebaud | febcce3 | 2015-08-07 20:05:31 +0200 | [diff] [blame] | 397 | |
| 398 | VERIFY((test_assign(Matrix57(), Matrix<Scalar,5*PacketSize,3>()*Matrix<Scalar,3,7>(), |
Gael Guennebaud | 91716f0 | 2018-09-21 14:32:24 +0200 | [diff] [blame] | 399 | InnerVectorizedTraversal, InnerUnrolling+CompleteUnrolling))); |
Gael Guennebaud | febcce3 | 2015-08-07 20:05:31 +0200 | [diff] [blame] | 400 | #endif |
| 401 | } |
| 402 | }; |
| 403 | |
| 404 | template<typename Scalar> struct vectorization_logic_half<Scalar,false> |
| 405 | { |
| 406 | static void run() {} |
| 407 | }; |
| 408 | |
Gael Guennebaud | 82f0ce2 | 2018-07-17 14:46:15 +0200 | [diff] [blame] | 409 | EIGEN_DECLARE_TEST(vectorization_logic) |
Gael Guennebaud | cb71dc4 | 2009-01-07 22:20:03 +0000 | [diff] [blame] | 410 | { |
| 411 | |
| 412 | #ifdef EIGEN_VECTORIZE |
| 413 | |
Christoph Hertzberg | 4f440b8 | 2014-07-14 14:36:20 +0200 | [diff] [blame] | 414 | CALL_SUBTEST( vectorization_logic<int>::run() ); |
Gael Guennebaud | 501bc60 | 2011-05-19 21:52:40 +0200 | [diff] [blame] | 415 | CALL_SUBTEST( vectorization_logic<float>::run() ); |
| 416 | CALL_SUBTEST( vectorization_logic<double>::run() ); |
| 417 | CALL_SUBTEST( vectorization_logic<std::complex<float> >::run() ); |
| 418 | CALL_SUBTEST( vectorization_logic<std::complex<double> >::run() ); |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 419 | |
Gael Guennebaud | febcce3 | 2015-08-07 20:05:31 +0200 | [diff] [blame] | 420 | CALL_SUBTEST( vectorization_logic_half<int>::run() ); |
| 421 | CALL_SUBTEST( vectorization_logic_half<float>::run() ); |
| 422 | CALL_SUBTEST( vectorization_logic_half<double>::run() ); |
| 423 | CALL_SUBTEST( vectorization_logic_half<std::complex<float> >::run() ); |
| 424 | CALL_SUBTEST( vectorization_logic_half<std::complex<double> >::run() ); |
| 425 | |
Benoit Jacob | 4716040 | 2010-10-25 10:15:22 -0400 | [diff] [blame] | 426 | if(internal::packet_traits<float>::Vectorizable) |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 427 | { |
| 428 | VERIFY(test_assign(Matrix<float,3,3>(),Matrix<float,3,3>()+Matrix<float,3,3>(), |
Gael Guennebaud | e68e165 | 2016-05-24 21:54:03 +0200 | [diff] [blame] | 429 | EIGEN_UNALIGNED_VECTORIZE ? LinearVectorizedTraversal : LinearTraversal,CompleteUnrolling)); |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 430 | |
| 431 | VERIFY(test_redux(Matrix<float,5,2>(), |
Gael Guennebaud | e68e165 | 2016-05-24 21:54:03 +0200 | [diff] [blame] | 432 | EIGEN_UNALIGNED_VECTORIZE ? LinearVectorizedTraversal : DefaultTraversal,CompleteUnrolling)); |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 433 | } |
| 434 | |
Benoit Jacob | 4716040 | 2010-10-25 10:15:22 -0400 | [diff] [blame] | 435 | if(internal::packet_traits<double>::Vectorizable) |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 436 | { |
| 437 | VERIFY(test_assign(Matrix<double,3,3>(),Matrix<double,3,3>()+Matrix<double,3,3>(), |
Gael Guennebaud | e68e165 | 2016-05-24 21:54:03 +0200 | [diff] [blame] | 438 | EIGEN_UNALIGNED_VECTORIZE ? LinearVectorizedTraversal : LinearTraversal,CompleteUnrolling)); |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 439 | |
| 440 | VERIFY(test_redux(Matrix<double,7,3>(), |
Gael Guennebaud | e68e165 | 2016-05-24 21:54:03 +0200 | [diff] [blame] | 441 | EIGEN_UNALIGNED_VECTORIZE ? LinearVectorizedTraversal : DefaultTraversal,CompleteUnrolling)); |
Gael Guennebaud | 51ec188 | 2010-07-08 23:30:16 +0200 | [diff] [blame] | 442 | } |
Gael Guennebaud | cb71dc4 | 2009-01-07 22:20:03 +0000 | [diff] [blame] | 443 | #endif // EIGEN_VECTORIZE |
| 444 | |
| 445 | } |