Reshaped.h (17033B)
1 // This file is part of Eigen, a lightweight C++ template library 2 // for linear algebra. 3 // 4 // Copyright (C) 2008-2017 Gael Guennebaud <gael.guennebaud@inria.fr> 5 // Copyright (C) 2014 yoco <peter.xiau@gmail.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 #ifndef EIGEN_RESHAPED_H 12 #define EIGEN_RESHAPED_H 13 14 namespace Eigen { 15 16 /** \class Reshaped 17 * \ingroup Core_Module 18 * 19 * \brief Expression of a fixed-size or dynamic-size reshape 20 * 21 * \tparam XprType the type of the expression in which we are taking a reshape 22 * \tparam Rows the number of rows of the reshape we are taking at compile time (optional) 23 * \tparam Cols the number of columns of the reshape we are taking at compile time (optional) 24 * \tparam Order can be ColMajor or RowMajor, default is ColMajor. 25 * 26 * This class represents an expression of either a fixed-size or dynamic-size reshape. 27 * It is the return type of DenseBase::reshaped(NRowsType,NColsType) and 28 * most of the time this is the only way it is used. 29 * 30 * However, in C++98, if you want to directly maniputate reshaped expressions, 31 * for instance if you want to write a function returning such an expression, you 32 * will need to use this class. In C++11, it is advised to use the \em auto 33 * keyword for such use cases. 34 * 35 * Here is an example illustrating the dynamic case: 36 * \include class_Reshaped.cpp 37 * Output: \verbinclude class_Reshaped.out 38 * 39 * Here is an example illustrating the fixed-size case: 40 * \include class_FixedReshaped.cpp 41 * Output: \verbinclude class_FixedReshaped.out 42 * 43 * \sa DenseBase::reshaped(NRowsType,NColsType) 44 */ 45 46 namespace internal { 47 48 template<typename XprType, int Rows, int Cols, int Order> 49 struct traits<Reshaped<XprType, Rows, Cols, Order> > : traits<XprType> 50 { 51 typedef typename traits<XprType>::Scalar Scalar; 52 typedef typename traits<XprType>::StorageKind StorageKind; 53 typedef typename traits<XprType>::XprKind XprKind; 54 enum{ 55 MatrixRows = traits<XprType>::RowsAtCompileTime, 56 MatrixCols = traits<XprType>::ColsAtCompileTime, 57 RowsAtCompileTime = Rows, 58 ColsAtCompileTime = Cols, 59 MaxRowsAtCompileTime = Rows, 60 MaxColsAtCompileTime = Cols, 61 XpxStorageOrder = ((int(traits<XprType>::Flags) & RowMajorBit) == RowMajorBit) ? RowMajor : ColMajor, 62 ReshapedStorageOrder = (RowsAtCompileTime == 1 && ColsAtCompileTime != 1) ? RowMajor 63 : (ColsAtCompileTime == 1 && RowsAtCompileTime != 1) ? ColMajor 64 : XpxStorageOrder, 65 HasSameStorageOrderAsXprType = (ReshapedStorageOrder == XpxStorageOrder), 66 InnerSize = (ReshapedStorageOrder==int(RowMajor)) ? int(ColsAtCompileTime) : int(RowsAtCompileTime), 67 InnerStrideAtCompileTime = HasSameStorageOrderAsXprType 68 ? int(inner_stride_at_compile_time<XprType>::ret) 69 : Dynamic, 70 OuterStrideAtCompileTime = Dynamic, 71 72 HasDirectAccess = internal::has_direct_access<XprType>::ret 73 && (Order==int(XpxStorageOrder)) 74 && ((evaluator<XprType>::Flags&LinearAccessBit)==LinearAccessBit), 75 76 MaskPacketAccessBit = (InnerSize == Dynamic || (InnerSize % packet_traits<Scalar>::size) == 0) 77 && (InnerStrideAtCompileTime == 1) 78 ? PacketAccessBit : 0, 79 //MaskAlignedBit = ((OuterStrideAtCompileTime!=Dynamic) && (((OuterStrideAtCompileTime * int(sizeof(Scalar))) % 16) == 0)) ? AlignedBit : 0, 80 FlagsLinearAccessBit = (RowsAtCompileTime == 1 || ColsAtCompileTime == 1) ? LinearAccessBit : 0, 81 FlagsLvalueBit = is_lvalue<XprType>::value ? LvalueBit : 0, 82 FlagsRowMajorBit = (ReshapedStorageOrder==int(RowMajor)) ? RowMajorBit : 0, 83 FlagsDirectAccessBit = HasDirectAccess ? DirectAccessBit : 0, 84 Flags0 = traits<XprType>::Flags & ( (HereditaryBits & ~RowMajorBit) | MaskPacketAccessBit), 85 86 Flags = (Flags0 | FlagsLinearAccessBit | FlagsLvalueBit | FlagsRowMajorBit | FlagsDirectAccessBit) 87 }; 88 }; 89 90 template<typename XprType, int Rows, int Cols, int Order, bool HasDirectAccess> class ReshapedImpl_dense; 91 92 } // end namespace internal 93 94 template<typename XprType, int Rows, int Cols, int Order, typename StorageKind> class ReshapedImpl; 95 96 template<typename XprType, int Rows, int Cols, int Order> class Reshaped 97 : public ReshapedImpl<XprType, Rows, Cols, Order, typename internal::traits<XprType>::StorageKind> 98 { 99 typedef ReshapedImpl<XprType, Rows, Cols, Order, typename internal::traits<XprType>::StorageKind> Impl; 100 public: 101 //typedef typename Impl::Base Base; 102 typedef Impl Base; 103 EIGEN_GENERIC_PUBLIC_INTERFACE(Reshaped) 104 EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Reshaped) 105 106 /** Fixed-size constructor 107 */ 108 EIGEN_DEVICE_FUNC 109 inline Reshaped(XprType& xpr) 110 : Impl(xpr) 111 { 112 EIGEN_STATIC_ASSERT(RowsAtCompileTime!=Dynamic && ColsAtCompileTime!=Dynamic,THIS_METHOD_IS_ONLY_FOR_FIXED_SIZE) 113 eigen_assert(Rows * Cols == xpr.rows() * xpr.cols()); 114 } 115 116 /** Dynamic-size constructor 117 */ 118 EIGEN_DEVICE_FUNC 119 inline Reshaped(XprType& xpr, 120 Index reshapeRows, Index reshapeCols) 121 : Impl(xpr, reshapeRows, reshapeCols) 122 { 123 eigen_assert((RowsAtCompileTime==Dynamic || RowsAtCompileTime==reshapeRows) 124 && (ColsAtCompileTime==Dynamic || ColsAtCompileTime==reshapeCols)); 125 eigen_assert(reshapeRows * reshapeCols == xpr.rows() * xpr.cols()); 126 } 127 }; 128 129 // The generic default implementation for dense reshape simply forward to the internal::ReshapedImpl_dense 130 // that must be specialized for direct and non-direct access... 131 template<typename XprType, int Rows, int Cols, int Order> 132 class ReshapedImpl<XprType, Rows, Cols, Order, Dense> 133 : public internal::ReshapedImpl_dense<XprType, Rows, Cols, Order,internal::traits<Reshaped<XprType,Rows,Cols,Order> >::HasDirectAccess> 134 { 135 typedef internal::ReshapedImpl_dense<XprType, Rows, Cols, Order,internal::traits<Reshaped<XprType,Rows,Cols,Order> >::HasDirectAccess> Impl; 136 public: 137 typedef Impl Base; 138 EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ReshapedImpl) 139 EIGEN_DEVICE_FUNC inline ReshapedImpl(XprType& xpr) : Impl(xpr) {} 140 EIGEN_DEVICE_FUNC inline ReshapedImpl(XprType& xpr, Index reshapeRows, Index reshapeCols) 141 : Impl(xpr, reshapeRows, reshapeCols) {} 142 }; 143 144 namespace internal { 145 146 /** \internal Internal implementation of dense Reshaped in the general case. */ 147 template<typename XprType, int Rows, int Cols, int Order> 148 class ReshapedImpl_dense<XprType,Rows,Cols,Order,false> 149 : public internal::dense_xpr_base<Reshaped<XprType, Rows, Cols, Order> >::type 150 { 151 typedef Reshaped<XprType, Rows, Cols, Order> ReshapedType; 152 public: 153 154 typedef typename internal::dense_xpr_base<ReshapedType>::type Base; 155 EIGEN_DENSE_PUBLIC_INTERFACE(ReshapedType) 156 EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ReshapedImpl_dense) 157 158 typedef typename internal::ref_selector<XprType>::non_const_type MatrixTypeNested; 159 typedef typename internal::remove_all<XprType>::type NestedExpression; 160 161 class InnerIterator; 162 163 /** Fixed-size constructor 164 */ 165 EIGEN_DEVICE_FUNC 166 inline ReshapedImpl_dense(XprType& xpr) 167 : m_xpr(xpr), m_rows(Rows), m_cols(Cols) 168 {} 169 170 /** Dynamic-size constructor 171 */ 172 EIGEN_DEVICE_FUNC 173 inline ReshapedImpl_dense(XprType& xpr, Index nRows, Index nCols) 174 : m_xpr(xpr), m_rows(nRows), m_cols(nCols) 175 {} 176 177 EIGEN_DEVICE_FUNC Index rows() const { return m_rows; } 178 EIGEN_DEVICE_FUNC Index cols() const { return m_cols; } 179 180 #ifdef EIGEN_PARSED_BY_DOXYGEN 181 /** \sa MapBase::data() */ 182 EIGEN_DEVICE_FUNC inline const Scalar* data() const; 183 EIGEN_DEVICE_FUNC inline Index innerStride() const; 184 EIGEN_DEVICE_FUNC inline Index outerStride() const; 185 #endif 186 187 /** \returns the nested expression */ 188 EIGEN_DEVICE_FUNC 189 const typename internal::remove_all<XprType>::type& 190 nestedExpression() const { return m_xpr; } 191 192 /** \returns the nested expression */ 193 EIGEN_DEVICE_FUNC 194 typename internal::remove_reference<XprType>::type& 195 nestedExpression() { return m_xpr; } 196 197 protected: 198 199 MatrixTypeNested m_xpr; 200 const internal::variable_if_dynamic<Index, Rows> m_rows; 201 const internal::variable_if_dynamic<Index, Cols> m_cols; 202 }; 203 204 205 /** \internal Internal implementation of dense Reshaped in the direct access case. */ 206 template<typename XprType, int Rows, int Cols, int Order> 207 class ReshapedImpl_dense<XprType, Rows, Cols, Order, true> 208 : public MapBase<Reshaped<XprType, Rows, Cols, Order> > 209 { 210 typedef Reshaped<XprType, Rows, Cols, Order> ReshapedType; 211 typedef typename internal::ref_selector<XprType>::non_const_type XprTypeNested; 212 public: 213 214 typedef MapBase<ReshapedType> Base; 215 EIGEN_DENSE_PUBLIC_INTERFACE(ReshapedType) 216 EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ReshapedImpl_dense) 217 218 /** Fixed-size constructor 219 */ 220 EIGEN_DEVICE_FUNC 221 inline ReshapedImpl_dense(XprType& xpr) 222 : Base(xpr.data()), m_xpr(xpr) 223 {} 224 225 /** Dynamic-size constructor 226 */ 227 EIGEN_DEVICE_FUNC 228 inline ReshapedImpl_dense(XprType& xpr, Index nRows, Index nCols) 229 : Base(xpr.data(), nRows, nCols), 230 m_xpr(xpr) 231 {} 232 233 EIGEN_DEVICE_FUNC 234 const typename internal::remove_all<XprTypeNested>::type& nestedExpression() const 235 { 236 return m_xpr; 237 } 238 239 EIGEN_DEVICE_FUNC 240 XprType& nestedExpression() { return m_xpr; } 241 242 /** \sa MapBase::innerStride() */ 243 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR 244 inline Index innerStride() const 245 { 246 return m_xpr.innerStride(); 247 } 248 249 /** \sa MapBase::outerStride() */ 250 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR 251 inline Index outerStride() const 252 { 253 return ((Flags&RowMajorBit)==RowMajorBit) ? this->cols() : this->rows(); 254 } 255 256 protected: 257 258 XprTypeNested m_xpr; 259 }; 260 261 // Evaluators 262 template<typename ArgType, int Rows, int Cols, int Order, bool HasDirectAccess> struct reshaped_evaluator; 263 264 template<typename ArgType, int Rows, int Cols, int Order> 265 struct evaluator<Reshaped<ArgType, Rows, Cols, Order> > 266 : reshaped_evaluator<ArgType, Rows, Cols, Order, traits<Reshaped<ArgType,Rows,Cols,Order> >::HasDirectAccess> 267 { 268 typedef Reshaped<ArgType, Rows, Cols, Order> XprType; 269 typedef typename XprType::Scalar Scalar; 270 // TODO: should check for smaller packet types 271 typedef typename packet_traits<Scalar>::type PacketScalar; 272 273 enum { 274 CoeffReadCost = evaluator<ArgType>::CoeffReadCost, 275 HasDirectAccess = traits<XprType>::HasDirectAccess, 276 277 // RowsAtCompileTime = traits<XprType>::RowsAtCompileTime, 278 // ColsAtCompileTime = traits<XprType>::ColsAtCompileTime, 279 // MaxRowsAtCompileTime = traits<XprType>::MaxRowsAtCompileTime, 280 // MaxColsAtCompileTime = traits<XprType>::MaxColsAtCompileTime, 281 // 282 // InnerStrideAtCompileTime = traits<XprType>::HasSameStorageOrderAsXprType 283 // ? int(inner_stride_at_compile_time<ArgType>::ret) 284 // : Dynamic, 285 // OuterStrideAtCompileTime = Dynamic, 286 287 FlagsLinearAccessBit = (traits<XprType>::RowsAtCompileTime == 1 || traits<XprType>::ColsAtCompileTime == 1 || HasDirectAccess) ? LinearAccessBit : 0, 288 FlagsRowMajorBit = (traits<XprType>::ReshapedStorageOrder==int(RowMajor)) ? RowMajorBit : 0, 289 FlagsDirectAccessBit = HasDirectAccess ? DirectAccessBit : 0, 290 Flags0 = evaluator<ArgType>::Flags & (HereditaryBits & ~RowMajorBit), 291 Flags = Flags0 | FlagsLinearAccessBit | FlagsRowMajorBit | FlagsDirectAccessBit, 292 293 PacketAlignment = unpacket_traits<PacketScalar>::alignment, 294 Alignment = evaluator<ArgType>::Alignment 295 }; 296 typedef reshaped_evaluator<ArgType, Rows, Cols, Order, HasDirectAccess> reshaped_evaluator_type; 297 EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : reshaped_evaluator_type(xpr) 298 { 299 EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost); 300 } 301 }; 302 303 template<typename ArgType, int Rows, int Cols, int Order> 304 struct reshaped_evaluator<ArgType, Rows, Cols, Order, /* HasDirectAccess */ false> 305 : evaluator_base<Reshaped<ArgType, Rows, Cols, Order> > 306 { 307 typedef Reshaped<ArgType, Rows, Cols, Order> XprType; 308 309 enum { 310 CoeffReadCost = evaluator<ArgType>::CoeffReadCost /* TODO + cost of index computations */, 311 312 Flags = (evaluator<ArgType>::Flags & (HereditaryBits /*| LinearAccessBit | DirectAccessBit*/)), 313 314 Alignment = 0 315 }; 316 317 EIGEN_DEVICE_FUNC explicit reshaped_evaluator(const XprType& xpr) : m_argImpl(xpr.nestedExpression()), m_xpr(xpr) 318 { 319 EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost); 320 } 321 322 typedef typename XprType::Scalar Scalar; 323 typedef typename XprType::CoeffReturnType CoeffReturnType; 324 325 typedef std::pair<Index, Index> RowCol; 326 327 inline RowCol index_remap(Index rowId, Index colId) const 328 { 329 if(Order==ColMajor) 330 { 331 const Index nth_elem_idx = colId * m_xpr.rows() + rowId; 332 return RowCol(nth_elem_idx % m_xpr.nestedExpression().rows(), 333 nth_elem_idx / m_xpr.nestedExpression().rows()); 334 } 335 else 336 { 337 const Index nth_elem_idx = colId + rowId * m_xpr.cols(); 338 return RowCol(nth_elem_idx / m_xpr.nestedExpression().cols(), 339 nth_elem_idx % m_xpr.nestedExpression().cols()); 340 } 341 } 342 343 EIGEN_DEVICE_FUNC 344 inline Scalar& coeffRef(Index rowId, Index colId) 345 { 346 EIGEN_STATIC_ASSERT_LVALUE(XprType) 347 const RowCol row_col = index_remap(rowId, colId); 348 return m_argImpl.coeffRef(row_col.first, row_col.second); 349 } 350 351 EIGEN_DEVICE_FUNC 352 inline const Scalar& coeffRef(Index rowId, Index colId) const 353 { 354 const RowCol row_col = index_remap(rowId, colId); 355 return m_argImpl.coeffRef(row_col.first, row_col.second); 356 } 357 358 EIGEN_DEVICE_FUNC 359 EIGEN_STRONG_INLINE const CoeffReturnType coeff(Index rowId, Index colId) const 360 { 361 const RowCol row_col = index_remap(rowId, colId); 362 return m_argImpl.coeff(row_col.first, row_col.second); 363 } 364 365 EIGEN_DEVICE_FUNC 366 inline Scalar& coeffRef(Index index) 367 { 368 EIGEN_STATIC_ASSERT_LVALUE(XprType) 369 const RowCol row_col = index_remap(Rows == 1 ? 0 : index, 370 Rows == 1 ? index : 0); 371 return m_argImpl.coeffRef(row_col.first, row_col.second); 372 373 } 374 375 EIGEN_DEVICE_FUNC 376 inline const Scalar& coeffRef(Index index) const 377 { 378 const RowCol row_col = index_remap(Rows == 1 ? 0 : index, 379 Rows == 1 ? index : 0); 380 return m_argImpl.coeffRef(row_col.first, row_col.second); 381 } 382 383 EIGEN_DEVICE_FUNC 384 inline const CoeffReturnType coeff(Index index) const 385 { 386 const RowCol row_col = index_remap(Rows == 1 ? 0 : index, 387 Rows == 1 ? index : 0); 388 return m_argImpl.coeff(row_col.first, row_col.second); 389 } 390 #if 0 391 EIGEN_DEVICE_FUNC 392 template<int LoadMode> 393 inline PacketScalar packet(Index rowId, Index colId) const 394 { 395 const RowCol row_col = index_remap(rowId, colId); 396 return m_argImpl.template packet<Unaligned>(row_col.first, row_col.second); 397 398 } 399 400 template<int LoadMode> 401 EIGEN_DEVICE_FUNC 402 inline void writePacket(Index rowId, Index colId, const PacketScalar& val) 403 { 404 const RowCol row_col = index_remap(rowId, colId); 405 m_argImpl.const_cast_derived().template writePacket<Unaligned> 406 (row_col.first, row_col.second, val); 407 } 408 409 template<int LoadMode> 410 EIGEN_DEVICE_FUNC 411 inline PacketScalar packet(Index index) const 412 { 413 const RowCol row_col = index_remap(RowsAtCompileTime == 1 ? 0 : index, 414 RowsAtCompileTime == 1 ? index : 0); 415 return m_argImpl.template packet<Unaligned>(row_col.first, row_col.second); 416 } 417 418 template<int LoadMode> 419 EIGEN_DEVICE_FUNC 420 inline void writePacket(Index index, const PacketScalar& val) 421 { 422 const RowCol row_col = index_remap(RowsAtCompileTime == 1 ? 0 : index, 423 RowsAtCompileTime == 1 ? index : 0); 424 return m_argImpl.template packet<Unaligned>(row_col.first, row_col.second, val); 425 } 426 #endif 427 protected: 428 429 evaluator<ArgType> m_argImpl; 430 const XprType& m_xpr; 431 432 }; 433 434 template<typename ArgType, int Rows, int Cols, int Order> 435 struct reshaped_evaluator<ArgType, Rows, Cols, Order, /* HasDirectAccess */ true> 436 : mapbase_evaluator<Reshaped<ArgType, Rows, Cols, Order>, 437 typename Reshaped<ArgType, Rows, Cols, Order>::PlainObject> 438 { 439 typedef Reshaped<ArgType, Rows, Cols, Order> XprType; 440 typedef typename XprType::Scalar Scalar; 441 442 EIGEN_DEVICE_FUNC explicit reshaped_evaluator(const XprType& xpr) 443 : mapbase_evaluator<XprType, typename XprType::PlainObject>(xpr) 444 { 445 // TODO: for the 3.4 release, this should be turned to an internal assertion, but let's keep it as is for the beta lifetime 446 eigen_assert(((internal::UIntPtr(xpr.data()) % EIGEN_PLAIN_ENUM_MAX(1,evaluator<XprType>::Alignment)) == 0) && "data is not aligned"); 447 } 448 }; 449 450 } // end namespace internal 451 452 } // end namespace Eigen 453 454 #endif // EIGEN_RESHAPED_H