[136] | 1 | // This file is part of Eigen, a lightweight C++ template library
|
---|
| 2 | // for linear algebra.
|
---|
| 3 | //
|
---|
| 4 | // Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
|
---|
| 5 | //
|
---|
| 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/.
|
---|
| 9 |
|
---|
| 10 | #ifndef EIGEN_DENSECOEFFSBASE_H
|
---|
| 11 | #define EIGEN_DENSECOEFFSBASE_H
|
---|
| 12 |
|
---|
| 13 | namespace Eigen {
|
---|
| 14 |
|
---|
| 15 | namespace internal {
|
---|
| 16 | template<typename T> struct add_const_on_value_type_if_arithmetic
|
---|
| 17 | {
|
---|
| 18 | typedef typename conditional<is_arithmetic<T>::value, T, typename add_const_on_value_type<T>::type>::type type;
|
---|
| 19 | };
|
---|
| 20 | }
|
---|
| 21 |
|
---|
| 22 | /** \brief Base class providing read-only coefficient access to matrices and arrays.
|
---|
| 23 | * \ingroup Core_Module
|
---|
| 24 | * \tparam Derived Type of the derived class
|
---|
| 25 | * \tparam #ReadOnlyAccessors Constant indicating read-only access
|
---|
| 26 | *
|
---|
| 27 | * This class defines the \c operator() \c const function and friends, which can be used to read specific
|
---|
| 28 | * entries of a matrix or array.
|
---|
| 29 | *
|
---|
| 30 | * \sa DenseCoeffsBase<Derived, WriteAccessors>, DenseCoeffsBase<Derived, DirectAccessors>,
|
---|
| 31 | * \ref TopicClassHierarchy
|
---|
| 32 | */
|
---|
| 33 | template<typename Derived>
|
---|
| 34 | class DenseCoeffsBase<Derived,ReadOnlyAccessors> : public EigenBase<Derived>
|
---|
| 35 | {
|
---|
| 36 | public:
|
---|
| 37 | typedef typename internal::traits<Derived>::StorageKind StorageKind;
|
---|
| 38 | typedef typename internal::traits<Derived>::Index Index;
|
---|
| 39 | typedef typename internal::traits<Derived>::Scalar Scalar;
|
---|
| 40 | typedef typename internal::packet_traits<Scalar>::type PacketScalar;
|
---|
| 41 |
|
---|
| 42 | // Explanation for this CoeffReturnType typedef.
|
---|
| 43 | // - This is the return type of the coeff() method.
|
---|
| 44 | // - The LvalueBit means exactly that we can offer a coeffRef() method, which means exactly that we can get references
|
---|
| 45 | // to coeffs, which means exactly that we can have coeff() return a const reference (as opposed to returning a value).
|
---|
| 46 | // - The is_artihmetic check is required since "const int", "const double", etc. will cause warnings on some systems
|
---|
| 47 | // while the declaration of "const T", where T is a non arithmetic type does not. Always returning "const Scalar&" is
|
---|
| 48 | // not possible, since the underlying expressions might not offer a valid address the reference could be referring to.
|
---|
| 49 | typedef typename internal::conditional<bool(internal::traits<Derived>::Flags&LvalueBit),
|
---|
| 50 | const Scalar&,
|
---|
| 51 | typename internal::conditional<internal::is_arithmetic<Scalar>::value, Scalar, const Scalar>::type
|
---|
| 52 | >::type CoeffReturnType;
|
---|
| 53 |
|
---|
| 54 | typedef typename internal::add_const_on_value_type_if_arithmetic<
|
---|
| 55 | typename internal::packet_traits<Scalar>::type
|
---|
| 56 | >::type PacketReturnType;
|
---|
| 57 |
|
---|
| 58 | typedef EigenBase<Derived> Base;
|
---|
| 59 | using Base::rows;
|
---|
| 60 | using Base::cols;
|
---|
| 61 | using Base::size;
|
---|
| 62 | using Base::derived;
|
---|
| 63 |
|
---|
| 64 | EIGEN_STRONG_INLINE Index rowIndexByOuterInner(Index outer, Index inner) const
|
---|
| 65 | {
|
---|
| 66 | return int(Derived::RowsAtCompileTime) == 1 ? 0
|
---|
| 67 | : int(Derived::ColsAtCompileTime) == 1 ? inner
|
---|
| 68 | : int(Derived::Flags)&RowMajorBit ? outer
|
---|
| 69 | : inner;
|
---|
| 70 | }
|
---|
| 71 |
|
---|
| 72 | EIGEN_STRONG_INLINE Index colIndexByOuterInner(Index outer, Index inner) const
|
---|
| 73 | {
|
---|
| 74 | return int(Derived::ColsAtCompileTime) == 1 ? 0
|
---|
| 75 | : int(Derived::RowsAtCompileTime) == 1 ? inner
|
---|
| 76 | : int(Derived::Flags)&RowMajorBit ? inner
|
---|
| 77 | : outer;
|
---|
| 78 | }
|
---|
| 79 |
|
---|
| 80 | /** Short version: don't use this function, use
|
---|
| 81 | * \link operator()(Index,Index) const \endlink instead.
|
---|
| 82 | *
|
---|
| 83 | * Long version: this function is similar to
|
---|
| 84 | * \link operator()(Index,Index) const \endlink, but without the assertion.
|
---|
| 85 | * Use this for limiting the performance cost of debugging code when doing
|
---|
| 86 | * repeated coefficient access. Only use this when it is guaranteed that the
|
---|
| 87 | * parameters \a row and \a col are in range.
|
---|
| 88 | *
|
---|
| 89 | * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this
|
---|
| 90 | * function equivalent to \link operator()(Index,Index) const \endlink.
|
---|
| 91 | *
|
---|
| 92 | * \sa operator()(Index,Index) const, coeffRef(Index,Index), coeff(Index) const
|
---|
| 93 | */
|
---|
| 94 | EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const
|
---|
| 95 | {
|
---|
| 96 | eigen_internal_assert(row >= 0 && row < rows()
|
---|
| 97 | && col >= 0 && col < cols());
|
---|
| 98 | return derived().coeff(row, col);
|
---|
| 99 | }
|
---|
| 100 |
|
---|
| 101 | EIGEN_STRONG_INLINE CoeffReturnType coeffByOuterInner(Index outer, Index inner) const
|
---|
| 102 | {
|
---|
| 103 | return coeff(rowIndexByOuterInner(outer, inner),
|
---|
| 104 | colIndexByOuterInner(outer, inner));
|
---|
| 105 | }
|
---|
| 106 |
|
---|
| 107 | /** \returns the coefficient at given the given row and column.
|
---|
| 108 | *
|
---|
| 109 | * \sa operator()(Index,Index), operator[](Index)
|
---|
| 110 | */
|
---|
| 111 | EIGEN_STRONG_INLINE CoeffReturnType operator()(Index row, Index col) const
|
---|
| 112 | {
|
---|
| 113 | eigen_assert(row >= 0 && row < rows()
|
---|
| 114 | && col >= 0 && col < cols());
|
---|
| 115 | return derived().coeff(row, col);
|
---|
| 116 | }
|
---|
| 117 |
|
---|
| 118 | /** Short version: don't use this function, use
|
---|
| 119 | * \link operator[](Index) const \endlink instead.
|
---|
| 120 | *
|
---|
| 121 | * Long version: this function is similar to
|
---|
| 122 | * \link operator[](Index) const \endlink, but without the assertion.
|
---|
| 123 | * Use this for limiting the performance cost of debugging code when doing
|
---|
| 124 | * repeated coefficient access. Only use this when it is guaranteed that the
|
---|
| 125 | * parameter \a index is in range.
|
---|
| 126 | *
|
---|
| 127 | * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this
|
---|
| 128 | * function equivalent to \link operator[](Index) const \endlink.
|
---|
| 129 | *
|
---|
| 130 | * \sa operator[](Index) const, coeffRef(Index), coeff(Index,Index) const
|
---|
| 131 | */
|
---|
| 132 |
|
---|
| 133 | EIGEN_STRONG_INLINE CoeffReturnType
|
---|
| 134 | coeff(Index index) const
|
---|
| 135 | {
|
---|
| 136 | eigen_internal_assert(index >= 0 && index < size());
|
---|
| 137 | return derived().coeff(index);
|
---|
| 138 | }
|
---|
| 139 |
|
---|
| 140 |
|
---|
| 141 | /** \returns the coefficient at given index.
|
---|
| 142 | *
|
---|
| 143 | * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
|
---|
| 144 | *
|
---|
| 145 | * \sa operator[](Index), operator()(Index,Index) const, x() const, y() const,
|
---|
| 146 | * z() const, w() const
|
---|
| 147 | */
|
---|
| 148 |
|
---|
| 149 | EIGEN_STRONG_INLINE CoeffReturnType
|
---|
| 150 | operator[](Index index) const
|
---|
| 151 | {
|
---|
| 152 | #ifndef EIGEN2_SUPPORT
|
---|
| 153 | EIGEN_STATIC_ASSERT(Derived::IsVectorAtCompileTime,
|
---|
| 154 | THE_BRACKET_OPERATOR_IS_ONLY_FOR_VECTORS__USE_THE_PARENTHESIS_OPERATOR_INSTEAD)
|
---|
| 155 | #endif
|
---|
| 156 | eigen_assert(index >= 0 && index < size());
|
---|
| 157 | return derived().coeff(index);
|
---|
| 158 | }
|
---|
| 159 |
|
---|
| 160 | /** \returns the coefficient at given index.
|
---|
| 161 | *
|
---|
| 162 | * This is synonymous to operator[](Index) const.
|
---|
| 163 | *
|
---|
| 164 | * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
|
---|
| 165 | *
|
---|
| 166 | * \sa operator[](Index), operator()(Index,Index) const, x() const, y() const,
|
---|
| 167 | * z() const, w() const
|
---|
| 168 | */
|
---|
| 169 |
|
---|
| 170 | EIGEN_STRONG_INLINE CoeffReturnType
|
---|
| 171 | operator()(Index index) const
|
---|
| 172 | {
|
---|
| 173 | eigen_assert(index >= 0 && index < size());
|
---|
| 174 | return derived().coeff(index);
|
---|
| 175 | }
|
---|
| 176 |
|
---|
| 177 | /** equivalent to operator[](0). */
|
---|
| 178 |
|
---|
| 179 | EIGEN_STRONG_INLINE CoeffReturnType
|
---|
| 180 | x() const { return (*this)[0]; }
|
---|
| 181 |
|
---|
| 182 | /** equivalent to operator[](1). */
|
---|
| 183 |
|
---|
| 184 | EIGEN_STRONG_INLINE CoeffReturnType
|
---|
| 185 | y() const { return (*this)[1]; }
|
---|
| 186 |
|
---|
| 187 | /** equivalent to operator[](2). */
|
---|
| 188 |
|
---|
| 189 | EIGEN_STRONG_INLINE CoeffReturnType
|
---|
| 190 | z() const { return (*this)[2]; }
|
---|
| 191 |
|
---|
| 192 | /** equivalent to operator[](3). */
|
---|
| 193 |
|
---|
| 194 | EIGEN_STRONG_INLINE CoeffReturnType
|
---|
| 195 | w() const { return (*this)[3]; }
|
---|
| 196 |
|
---|
| 197 | /** \internal
|
---|
| 198 | * \returns the packet of coefficients starting at the given row and column. It is your responsibility
|
---|
| 199 | * to ensure that a packet really starts there. This method is only available on expressions having the
|
---|
| 200 | * PacketAccessBit.
|
---|
| 201 | *
|
---|
| 202 | * The \a LoadMode parameter may have the value \a #Aligned or \a #Unaligned. Its effect is to select
|
---|
| 203 | * the appropriate vectorization instruction. Aligned access is faster, but is only possible for packets
|
---|
| 204 | * starting at an address which is a multiple of the packet size.
|
---|
| 205 | */
|
---|
| 206 |
|
---|
| 207 | template<int LoadMode>
|
---|
| 208 | EIGEN_STRONG_INLINE PacketReturnType packet(Index row, Index col) const
|
---|
| 209 | {
|
---|
| 210 | eigen_internal_assert(row >= 0 && row < rows()
|
---|
| 211 | && col >= 0 && col < cols());
|
---|
| 212 | return derived().template packet<LoadMode>(row,col);
|
---|
| 213 | }
|
---|
| 214 |
|
---|
| 215 |
|
---|
| 216 | /** \internal */
|
---|
| 217 | template<int LoadMode>
|
---|
| 218 | EIGEN_STRONG_INLINE PacketReturnType packetByOuterInner(Index outer, Index inner) const
|
---|
| 219 | {
|
---|
| 220 | return packet<LoadMode>(rowIndexByOuterInner(outer, inner),
|
---|
| 221 | colIndexByOuterInner(outer, inner));
|
---|
| 222 | }
|
---|
| 223 |
|
---|
| 224 | /** \internal
|
---|
| 225 | * \returns the packet of coefficients starting at the given index. It is your responsibility
|
---|
| 226 | * to ensure that a packet really starts there. This method is only available on expressions having the
|
---|
| 227 | * PacketAccessBit and the LinearAccessBit.
|
---|
| 228 | *
|
---|
| 229 | * The \a LoadMode parameter may have the value \a #Aligned or \a #Unaligned. Its effect is to select
|
---|
| 230 | * the appropriate vectorization instruction. Aligned access is faster, but is only possible for packets
|
---|
| 231 | * starting at an address which is a multiple of the packet size.
|
---|
| 232 | */
|
---|
| 233 |
|
---|
| 234 | template<int LoadMode>
|
---|
| 235 | EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const
|
---|
| 236 | {
|
---|
| 237 | eigen_internal_assert(index >= 0 && index < size());
|
---|
| 238 | return derived().template packet<LoadMode>(index);
|
---|
| 239 | }
|
---|
| 240 |
|
---|
| 241 | protected:
|
---|
| 242 | // explanation: DenseBase is doing "using ..." on the methods from DenseCoeffsBase.
|
---|
| 243 | // But some methods are only available in the DirectAccess case.
|
---|
| 244 | // So we add dummy methods here with these names, so that "using... " doesn't fail.
|
---|
| 245 | // It's not private so that the child class DenseBase can access them, and it's not public
|
---|
| 246 | // either since it's an implementation detail, so has to be protected.
|
---|
| 247 | void coeffRef();
|
---|
| 248 | void coeffRefByOuterInner();
|
---|
| 249 | void writePacket();
|
---|
| 250 | void writePacketByOuterInner();
|
---|
| 251 | void copyCoeff();
|
---|
| 252 | void copyCoeffByOuterInner();
|
---|
| 253 | void copyPacket();
|
---|
| 254 | void copyPacketByOuterInner();
|
---|
| 255 | void stride();
|
---|
| 256 | void innerStride();
|
---|
| 257 | void outerStride();
|
---|
| 258 | void rowStride();
|
---|
| 259 | void colStride();
|
---|
| 260 | };
|
---|
| 261 |
|
---|
| 262 | /** \brief Base class providing read/write coefficient access to matrices and arrays.
|
---|
| 263 | * \ingroup Core_Module
|
---|
| 264 | * \tparam Derived Type of the derived class
|
---|
| 265 | * \tparam #WriteAccessors Constant indicating read/write access
|
---|
| 266 | *
|
---|
| 267 | * This class defines the non-const \c operator() function and friends, which can be used to write specific
|
---|
| 268 | * entries of a matrix or array. This class inherits DenseCoeffsBase<Derived, ReadOnlyAccessors> which
|
---|
| 269 | * defines the const variant for reading specific entries.
|
---|
| 270 | *
|
---|
| 271 | * \sa DenseCoeffsBase<Derived, DirectAccessors>, \ref TopicClassHierarchy
|
---|
| 272 | */
|
---|
| 273 | template<typename Derived>
|
---|
| 274 | class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived, ReadOnlyAccessors>
|
---|
| 275 | {
|
---|
| 276 | public:
|
---|
| 277 |
|
---|
| 278 | typedef DenseCoeffsBase<Derived, ReadOnlyAccessors> Base;
|
---|
| 279 |
|
---|
| 280 | typedef typename internal::traits<Derived>::StorageKind StorageKind;
|
---|
| 281 | typedef typename internal::traits<Derived>::Index Index;
|
---|
| 282 | typedef typename internal::traits<Derived>::Scalar Scalar;
|
---|
| 283 | typedef typename internal::packet_traits<Scalar>::type PacketScalar;
|
---|
| 284 | typedef typename NumTraits<Scalar>::Real RealScalar;
|
---|
| 285 |
|
---|
| 286 | using Base::coeff;
|
---|
| 287 | using Base::rows;
|
---|
| 288 | using Base::cols;
|
---|
| 289 | using Base::size;
|
---|
| 290 | using Base::derived;
|
---|
| 291 | using Base::rowIndexByOuterInner;
|
---|
| 292 | using Base::colIndexByOuterInner;
|
---|
| 293 | using Base::operator[];
|
---|
| 294 | using Base::operator();
|
---|
| 295 | using Base::x;
|
---|
| 296 | using Base::y;
|
---|
| 297 | using Base::z;
|
---|
| 298 | using Base::w;
|
---|
| 299 |
|
---|
| 300 | /** Short version: don't use this function, use
|
---|
| 301 | * \link operator()(Index,Index) \endlink instead.
|
---|
| 302 | *
|
---|
| 303 | * Long version: this function is similar to
|
---|
| 304 | * \link operator()(Index,Index) \endlink, but without the assertion.
|
---|
| 305 | * Use this for limiting the performance cost of debugging code when doing
|
---|
| 306 | * repeated coefficient access. Only use this when it is guaranteed that the
|
---|
| 307 | * parameters \a row and \a col are in range.
|
---|
| 308 | *
|
---|
| 309 | * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this
|
---|
| 310 | * function equivalent to \link operator()(Index,Index) \endlink.
|
---|
| 311 | *
|
---|
| 312 | * \sa operator()(Index,Index), coeff(Index, Index) const, coeffRef(Index)
|
---|
| 313 | */
|
---|
| 314 | EIGEN_STRONG_INLINE Scalar& coeffRef(Index row, Index col)
|
---|
| 315 | {
|
---|
| 316 | eigen_internal_assert(row >= 0 && row < rows()
|
---|
| 317 | && col >= 0 && col < cols());
|
---|
| 318 | return derived().coeffRef(row, col);
|
---|
| 319 | }
|
---|
| 320 |
|
---|
| 321 | EIGEN_STRONG_INLINE Scalar&
|
---|
| 322 | coeffRefByOuterInner(Index outer, Index inner)
|
---|
| 323 | {
|
---|
| 324 | return coeffRef(rowIndexByOuterInner(outer, inner),
|
---|
| 325 | colIndexByOuterInner(outer, inner));
|
---|
| 326 | }
|
---|
| 327 |
|
---|
| 328 | /** \returns a reference to the coefficient at given the given row and column.
|
---|
| 329 | *
|
---|
| 330 | * \sa operator[](Index)
|
---|
| 331 | */
|
---|
| 332 |
|
---|
| 333 | EIGEN_STRONG_INLINE Scalar&
|
---|
| 334 | operator()(Index row, Index col)
|
---|
| 335 | {
|
---|
| 336 | eigen_assert(row >= 0 && row < rows()
|
---|
| 337 | && col >= 0 && col < cols());
|
---|
| 338 | return derived().coeffRef(row, col);
|
---|
| 339 | }
|
---|
| 340 |
|
---|
| 341 |
|
---|
| 342 | /** Short version: don't use this function, use
|
---|
| 343 | * \link operator[](Index) \endlink instead.
|
---|
| 344 | *
|
---|
| 345 | * Long version: this function is similar to
|
---|
| 346 | * \link operator[](Index) \endlink, but without the assertion.
|
---|
| 347 | * Use this for limiting the performance cost of debugging code when doing
|
---|
| 348 | * repeated coefficient access. Only use this when it is guaranteed that the
|
---|
| 349 | * parameters \a row and \a col are in range.
|
---|
| 350 | *
|
---|
| 351 | * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this
|
---|
| 352 | * function equivalent to \link operator[](Index) \endlink.
|
---|
| 353 | *
|
---|
| 354 | * \sa operator[](Index), coeff(Index) const, coeffRef(Index,Index)
|
---|
| 355 | */
|
---|
| 356 |
|
---|
| 357 | EIGEN_STRONG_INLINE Scalar&
|
---|
| 358 | coeffRef(Index index)
|
---|
| 359 | {
|
---|
| 360 | eigen_internal_assert(index >= 0 && index < size());
|
---|
| 361 | return derived().coeffRef(index);
|
---|
| 362 | }
|
---|
| 363 |
|
---|
| 364 | /** \returns a reference to the coefficient at given index.
|
---|
| 365 | *
|
---|
| 366 | * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
|
---|
| 367 | *
|
---|
| 368 | * \sa operator[](Index) const, operator()(Index,Index), x(), y(), z(), w()
|
---|
| 369 | */
|
---|
| 370 |
|
---|
| 371 | EIGEN_STRONG_INLINE Scalar&
|
---|
| 372 | operator[](Index index)
|
---|
| 373 | {
|
---|
| 374 | #ifndef EIGEN2_SUPPORT
|
---|
| 375 | EIGEN_STATIC_ASSERT(Derived::IsVectorAtCompileTime,
|
---|
| 376 | THE_BRACKET_OPERATOR_IS_ONLY_FOR_VECTORS__USE_THE_PARENTHESIS_OPERATOR_INSTEAD)
|
---|
| 377 | #endif
|
---|
| 378 | eigen_assert(index >= 0 && index < size());
|
---|
| 379 | return derived().coeffRef(index);
|
---|
| 380 | }
|
---|
| 381 |
|
---|
| 382 | /** \returns a reference to the coefficient at given index.
|
---|
| 383 | *
|
---|
| 384 | * This is synonymous to operator[](Index).
|
---|
| 385 | *
|
---|
| 386 | * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
|
---|
| 387 | *
|
---|
| 388 | * \sa operator[](Index) const, operator()(Index,Index), x(), y(), z(), w()
|
---|
| 389 | */
|
---|
| 390 |
|
---|
| 391 | EIGEN_STRONG_INLINE Scalar&
|
---|
| 392 | operator()(Index index)
|
---|
| 393 | {
|
---|
| 394 | eigen_assert(index >= 0 && index < size());
|
---|
| 395 | return derived().coeffRef(index);
|
---|
| 396 | }
|
---|
| 397 |
|
---|
| 398 | /** equivalent to operator[](0). */
|
---|
| 399 |
|
---|
| 400 | EIGEN_STRONG_INLINE Scalar&
|
---|
| 401 | x() { return (*this)[0]; }
|
---|
| 402 |
|
---|
| 403 | /** equivalent to operator[](1). */
|
---|
| 404 |
|
---|
| 405 | EIGEN_STRONG_INLINE Scalar&
|
---|
| 406 | y() { return (*this)[1]; }
|
---|
| 407 |
|
---|
| 408 | /** equivalent to operator[](2). */
|
---|
| 409 |
|
---|
| 410 | EIGEN_STRONG_INLINE Scalar&
|
---|
| 411 | z() { return (*this)[2]; }
|
---|
| 412 |
|
---|
| 413 | /** equivalent to operator[](3). */
|
---|
| 414 |
|
---|
| 415 | EIGEN_STRONG_INLINE Scalar&
|
---|
| 416 | w() { return (*this)[3]; }
|
---|
| 417 |
|
---|
| 418 | /** \internal
|
---|
| 419 | * Stores the given packet of coefficients, at the given row and column of this expression. It is your responsibility
|
---|
| 420 | * to ensure that a packet really starts there. This method is only available on expressions having the
|
---|
| 421 | * PacketAccessBit.
|
---|
| 422 | *
|
---|
| 423 | * The \a LoadMode parameter may have the value \a #Aligned or \a #Unaligned. Its effect is to select
|
---|
| 424 | * the appropriate vectorization instruction. Aligned access is faster, but is only possible for packets
|
---|
| 425 | * starting at an address which is a multiple of the packet size.
|
---|
| 426 | */
|
---|
| 427 |
|
---|
| 428 | template<int StoreMode>
|
---|
| 429 | EIGEN_STRONG_INLINE void writePacket
|
---|
| 430 | (Index row, Index col, const typename internal::packet_traits<Scalar>::type& val)
|
---|
| 431 | {
|
---|
| 432 | eigen_internal_assert(row >= 0 && row < rows()
|
---|
| 433 | && col >= 0 && col < cols());
|
---|
| 434 | derived().template writePacket<StoreMode>(row,col,val);
|
---|
| 435 | }
|
---|
| 436 |
|
---|
| 437 |
|
---|
| 438 | /** \internal */
|
---|
| 439 | template<int StoreMode>
|
---|
| 440 | EIGEN_STRONG_INLINE void writePacketByOuterInner
|
---|
| 441 | (Index outer, Index inner, const typename internal::packet_traits<Scalar>::type& val)
|
---|
| 442 | {
|
---|
| 443 | writePacket<StoreMode>(rowIndexByOuterInner(outer, inner),
|
---|
| 444 | colIndexByOuterInner(outer, inner),
|
---|
| 445 | val);
|
---|
| 446 | }
|
---|
| 447 |
|
---|
| 448 | /** \internal
|
---|
| 449 | * Stores the given packet of coefficients, at the given index in this expression. It is your responsibility
|
---|
| 450 | * to ensure that a packet really starts there. This method is only available on expressions having the
|
---|
| 451 | * PacketAccessBit and the LinearAccessBit.
|
---|
| 452 | *
|
---|
| 453 | * The \a LoadMode parameter may have the value \a Aligned or \a Unaligned. Its effect is to select
|
---|
| 454 | * the appropriate vectorization instruction. Aligned access is faster, but is only possible for packets
|
---|
| 455 | * starting at an address which is a multiple of the packet size.
|
---|
| 456 | */
|
---|
| 457 | template<int StoreMode>
|
---|
| 458 | EIGEN_STRONG_INLINE void writePacket
|
---|
| 459 | (Index index, const typename internal::packet_traits<Scalar>::type& val)
|
---|
| 460 | {
|
---|
| 461 | eigen_internal_assert(index >= 0 && index < size());
|
---|
| 462 | derived().template writePacket<StoreMode>(index,val);
|
---|
| 463 | }
|
---|
| 464 |
|
---|
| 465 | #ifndef EIGEN_PARSED_BY_DOXYGEN
|
---|
| 466 |
|
---|
| 467 | /** \internal Copies the coefficient at position (row,col) of other into *this.
|
---|
| 468 | *
|
---|
| 469 | * This method is overridden in SwapWrapper, allowing swap() assignments to share 99% of their code
|
---|
| 470 | * with usual assignments.
|
---|
| 471 | *
|
---|
| 472 | * Outside of this internal usage, this method has probably no usefulness. It is hidden in the public API dox.
|
---|
| 473 | */
|
---|
| 474 |
|
---|
| 475 | template<typename OtherDerived>
|
---|
| 476 | EIGEN_STRONG_INLINE void copyCoeff(Index row, Index col, const DenseBase<OtherDerived>& other)
|
---|
| 477 | {
|
---|
| 478 | eigen_internal_assert(row >= 0 && row < rows()
|
---|
| 479 | && col >= 0 && col < cols());
|
---|
| 480 | derived().coeffRef(row, col) = other.derived().coeff(row, col);
|
---|
| 481 | }
|
---|
| 482 |
|
---|
| 483 | /** \internal Copies the coefficient at the given index of other into *this.
|
---|
| 484 | *
|
---|
| 485 | * This method is overridden in SwapWrapper, allowing swap() assignments to share 99% of their code
|
---|
| 486 | * with usual assignments.
|
---|
| 487 | *
|
---|
| 488 | * Outside of this internal usage, this method has probably no usefulness. It is hidden in the public API dox.
|
---|
| 489 | */
|
---|
| 490 |
|
---|
| 491 | template<typename OtherDerived>
|
---|
| 492 | EIGEN_STRONG_INLINE void copyCoeff(Index index, const DenseBase<OtherDerived>& other)
|
---|
| 493 | {
|
---|
| 494 | eigen_internal_assert(index >= 0 && index < size());
|
---|
| 495 | derived().coeffRef(index) = other.derived().coeff(index);
|
---|
| 496 | }
|
---|
| 497 |
|
---|
| 498 |
|
---|
| 499 | template<typename OtherDerived>
|
---|
| 500 | EIGEN_STRONG_INLINE void copyCoeffByOuterInner(Index outer, Index inner, const DenseBase<OtherDerived>& other)
|
---|
| 501 | {
|
---|
| 502 | const Index row = rowIndexByOuterInner(outer,inner);
|
---|
| 503 | const Index col = colIndexByOuterInner(outer,inner);
|
---|
| 504 | // derived() is important here: copyCoeff() may be reimplemented in Derived!
|
---|
| 505 | derived().copyCoeff(row, col, other);
|
---|
| 506 | }
|
---|
| 507 |
|
---|
| 508 | /** \internal Copies the packet at position (row,col) of other into *this.
|
---|
| 509 | *
|
---|
| 510 | * This method is overridden in SwapWrapper, allowing swap() assignments to share 99% of their code
|
---|
| 511 | * with usual assignments.
|
---|
| 512 | *
|
---|
| 513 | * Outside of this internal usage, this method has probably no usefulness. It is hidden in the public API dox.
|
---|
| 514 | */
|
---|
| 515 |
|
---|
| 516 | template<typename OtherDerived, int StoreMode, int LoadMode>
|
---|
| 517 | EIGEN_STRONG_INLINE void copyPacket(Index row, Index col, const DenseBase<OtherDerived>& other)
|
---|
| 518 | {
|
---|
| 519 | eigen_internal_assert(row >= 0 && row < rows()
|
---|
| 520 | && col >= 0 && col < cols());
|
---|
| 521 | derived().template writePacket<StoreMode>(row, col,
|
---|
| 522 | other.derived().template packet<LoadMode>(row, col));
|
---|
| 523 | }
|
---|
| 524 |
|
---|
| 525 | /** \internal Copies the packet at the given index of other into *this.
|
---|
| 526 | *
|
---|
| 527 | * This method is overridden in SwapWrapper, allowing swap() assignments to share 99% of their code
|
---|
| 528 | * with usual assignments.
|
---|
| 529 | *
|
---|
| 530 | * Outside of this internal usage, this method has probably no usefulness. It is hidden in the public API dox.
|
---|
| 531 | */
|
---|
| 532 |
|
---|
| 533 | template<typename OtherDerived, int StoreMode, int LoadMode>
|
---|
| 534 | EIGEN_STRONG_INLINE void copyPacket(Index index, const DenseBase<OtherDerived>& other)
|
---|
| 535 | {
|
---|
| 536 | eigen_internal_assert(index >= 0 && index < size());
|
---|
| 537 | derived().template writePacket<StoreMode>(index,
|
---|
| 538 | other.derived().template packet<LoadMode>(index));
|
---|
| 539 | }
|
---|
| 540 |
|
---|
| 541 | /** \internal */
|
---|
| 542 | template<typename OtherDerived, int StoreMode, int LoadMode>
|
---|
| 543 | EIGEN_STRONG_INLINE void copyPacketByOuterInner(Index outer, Index inner, const DenseBase<OtherDerived>& other)
|
---|
| 544 | {
|
---|
| 545 | const Index row = rowIndexByOuterInner(outer,inner);
|
---|
| 546 | const Index col = colIndexByOuterInner(outer,inner);
|
---|
| 547 | // derived() is important here: copyCoeff() may be reimplemented in Derived!
|
---|
| 548 | derived().template copyPacket< OtherDerived, StoreMode, LoadMode>(row, col, other);
|
---|
| 549 | }
|
---|
| 550 | #endif
|
---|
| 551 |
|
---|
| 552 | };
|
---|
| 553 |
|
---|
| 554 | /** \brief Base class providing direct read-only coefficient access to matrices and arrays.
|
---|
| 555 | * \ingroup Core_Module
|
---|
| 556 | * \tparam Derived Type of the derived class
|
---|
| 557 | * \tparam #DirectAccessors Constant indicating direct access
|
---|
| 558 | *
|
---|
| 559 | * This class defines functions to work with strides which can be used to access entries directly. This class
|
---|
| 560 | * inherits DenseCoeffsBase<Derived, ReadOnlyAccessors> which defines functions to access entries read-only using
|
---|
| 561 | * \c operator() .
|
---|
| 562 | *
|
---|
| 563 | * \sa \ref TopicClassHierarchy
|
---|
| 564 | */
|
---|
| 565 | template<typename Derived>
|
---|
| 566 | class DenseCoeffsBase<Derived, DirectAccessors> : public DenseCoeffsBase<Derived, ReadOnlyAccessors>
|
---|
| 567 | {
|
---|
| 568 | public:
|
---|
| 569 |
|
---|
| 570 | typedef DenseCoeffsBase<Derived, ReadOnlyAccessors> Base;
|
---|
| 571 | typedef typename internal::traits<Derived>::Index Index;
|
---|
| 572 | typedef typename internal::traits<Derived>::Scalar Scalar;
|
---|
| 573 | typedef typename NumTraits<Scalar>::Real RealScalar;
|
---|
| 574 |
|
---|
| 575 | using Base::rows;
|
---|
| 576 | using Base::cols;
|
---|
| 577 | using Base::size;
|
---|
| 578 | using Base::derived;
|
---|
| 579 |
|
---|
| 580 | /** \returns the pointer increment between two consecutive elements within a slice in the inner direction.
|
---|
| 581 | *
|
---|
| 582 | * \sa outerStride(), rowStride(), colStride()
|
---|
| 583 | */
|
---|
| 584 | inline Index innerStride() const
|
---|
| 585 | {
|
---|
| 586 | return derived().innerStride();
|
---|
| 587 | }
|
---|
| 588 |
|
---|
| 589 | /** \returns the pointer increment between two consecutive inner slices (for example, between two consecutive columns
|
---|
| 590 | * in a column-major matrix).
|
---|
| 591 | *
|
---|
| 592 | * \sa innerStride(), rowStride(), colStride()
|
---|
| 593 | */
|
---|
| 594 | inline Index outerStride() const
|
---|
| 595 | {
|
---|
| 596 | return derived().outerStride();
|
---|
| 597 | }
|
---|
| 598 |
|
---|
| 599 | // FIXME shall we remove it ?
|
---|
| 600 | inline Index stride() const
|
---|
| 601 | {
|
---|
| 602 | return Derived::IsVectorAtCompileTime ? innerStride() : outerStride();
|
---|
| 603 | }
|
---|
| 604 |
|
---|
| 605 | /** \returns the pointer increment between two consecutive rows.
|
---|
| 606 | *
|
---|
| 607 | * \sa innerStride(), outerStride(), colStride()
|
---|
| 608 | */
|
---|
| 609 | inline Index rowStride() const
|
---|
| 610 | {
|
---|
| 611 | return Derived::IsRowMajor ? outerStride() : innerStride();
|
---|
| 612 | }
|
---|
| 613 |
|
---|
| 614 | /** \returns the pointer increment between two consecutive columns.
|
---|
| 615 | *
|
---|
| 616 | * \sa innerStride(), outerStride(), rowStride()
|
---|
| 617 | */
|
---|
| 618 | inline Index colStride() const
|
---|
| 619 | {
|
---|
| 620 | return Derived::IsRowMajor ? innerStride() : outerStride();
|
---|
| 621 | }
|
---|
| 622 | };
|
---|
| 623 |
|
---|
| 624 | /** \brief Base class providing direct read/write coefficient access to matrices and arrays.
|
---|
| 625 | * \ingroup Core_Module
|
---|
| 626 | * \tparam Derived Type of the derived class
|
---|
| 627 | * \tparam #DirectWriteAccessors Constant indicating direct access
|
---|
| 628 | *
|
---|
| 629 | * This class defines functions to work with strides which can be used to access entries directly. This class
|
---|
| 630 | * inherits DenseCoeffsBase<Derived, WriteAccessors> which defines functions to access entries read/write using
|
---|
| 631 | * \c operator().
|
---|
| 632 | *
|
---|
| 633 | * \sa \ref TopicClassHierarchy
|
---|
| 634 | */
|
---|
| 635 | template<typename Derived>
|
---|
| 636 | class DenseCoeffsBase<Derived, DirectWriteAccessors>
|
---|
| 637 | : public DenseCoeffsBase<Derived, WriteAccessors>
|
---|
| 638 | {
|
---|
| 639 | public:
|
---|
| 640 |
|
---|
| 641 | typedef DenseCoeffsBase<Derived, WriteAccessors> Base;
|
---|
| 642 | typedef typename internal::traits<Derived>::Index Index;
|
---|
| 643 | typedef typename internal::traits<Derived>::Scalar Scalar;
|
---|
| 644 | typedef typename NumTraits<Scalar>::Real RealScalar;
|
---|
| 645 |
|
---|
| 646 | using Base::rows;
|
---|
| 647 | using Base::cols;
|
---|
| 648 | using Base::size;
|
---|
| 649 | using Base::derived;
|
---|
| 650 |
|
---|
| 651 | /** \returns the pointer increment between two consecutive elements within a slice in the inner direction.
|
---|
| 652 | *
|
---|
| 653 | * \sa outerStride(), rowStride(), colStride()
|
---|
| 654 | */
|
---|
| 655 | inline Index innerStride() const
|
---|
| 656 | {
|
---|
| 657 | return derived().innerStride();
|
---|
| 658 | }
|
---|
| 659 |
|
---|
| 660 | /** \returns the pointer increment between two consecutive inner slices (for example, between two consecutive columns
|
---|
| 661 | * in a column-major matrix).
|
---|
| 662 | *
|
---|
| 663 | * \sa innerStride(), rowStride(), colStride()
|
---|
| 664 | */
|
---|
| 665 | inline Index outerStride() const
|
---|
| 666 | {
|
---|
| 667 | return derived().outerStride();
|
---|
| 668 | }
|
---|
| 669 |
|
---|
| 670 | // FIXME shall we remove it ?
|
---|
| 671 | inline Index stride() const
|
---|
| 672 | {
|
---|
| 673 | return Derived::IsVectorAtCompileTime ? innerStride() : outerStride();
|
---|
| 674 | }
|
---|
| 675 |
|
---|
| 676 | /** \returns the pointer increment between two consecutive rows.
|
---|
| 677 | *
|
---|
| 678 | * \sa innerStride(), outerStride(), colStride()
|
---|
| 679 | */
|
---|
| 680 | inline Index rowStride() const
|
---|
| 681 | {
|
---|
| 682 | return Derived::IsRowMajor ? outerStride() : innerStride();
|
---|
| 683 | }
|
---|
| 684 |
|
---|
| 685 | /** \returns the pointer increment between two consecutive columns.
|
---|
| 686 | *
|
---|
| 687 | * \sa innerStride(), outerStride(), rowStride()
|
---|
| 688 | */
|
---|
| 689 | inline Index colStride() const
|
---|
| 690 | {
|
---|
| 691 | return Derived::IsRowMajor ? innerStride() : outerStride();
|
---|
| 692 | }
|
---|
| 693 | };
|
---|
| 694 |
|
---|
| 695 | namespace internal {
|
---|
| 696 |
|
---|
| 697 | template<typename Derived, bool JustReturnZero>
|
---|
| 698 | struct first_aligned_impl
|
---|
| 699 | {
|
---|
| 700 | static inline typename Derived::Index run(const Derived&)
|
---|
| 701 | { return 0; }
|
---|
| 702 | };
|
---|
| 703 |
|
---|
| 704 | template<typename Derived>
|
---|
| 705 | struct first_aligned_impl<Derived, false>
|
---|
| 706 | {
|
---|
| 707 | static inline typename Derived::Index run(const Derived& m)
|
---|
| 708 | {
|
---|
| 709 | return internal::first_aligned(&m.const_cast_derived().coeffRef(0,0), m.size());
|
---|
| 710 | }
|
---|
| 711 | };
|
---|
| 712 |
|
---|
| 713 | /** \internal \returns the index of the first element of the array that is well aligned for vectorization.
|
---|
| 714 | *
|
---|
| 715 | * There is also the variant first_aligned(const Scalar*, Integer) defined in Memory.h. See it for more
|
---|
| 716 | * documentation.
|
---|
| 717 | */
|
---|
| 718 | template<typename Derived>
|
---|
| 719 | static inline typename Derived::Index first_aligned(const Derived& m)
|
---|
| 720 | {
|
---|
| 721 | return first_aligned_impl
|
---|
| 722 | <Derived, (Derived::Flags & AlignedBit) || !(Derived::Flags & DirectAccessBit)>
|
---|
| 723 | ::run(m);
|
---|
| 724 | }
|
---|
| 725 |
|
---|
| 726 | template<typename Derived, bool HasDirectAccess = has_direct_access<Derived>::ret>
|
---|
| 727 | struct inner_stride_at_compile_time
|
---|
| 728 | {
|
---|
| 729 | enum { ret = traits<Derived>::InnerStrideAtCompileTime };
|
---|
| 730 | };
|
---|
| 731 |
|
---|
| 732 | template<typename Derived>
|
---|
| 733 | struct inner_stride_at_compile_time<Derived, false>
|
---|
| 734 | {
|
---|
| 735 | enum { ret = 0 };
|
---|
| 736 | };
|
---|
| 737 |
|
---|
| 738 | template<typename Derived, bool HasDirectAccess = has_direct_access<Derived>::ret>
|
---|
| 739 | struct outer_stride_at_compile_time
|
---|
| 740 | {
|
---|
| 741 | enum { ret = traits<Derived>::OuterStrideAtCompileTime };
|
---|
| 742 | };
|
---|
| 743 |
|
---|
| 744 | template<typename Derived>
|
---|
| 745 | struct outer_stride_at_compile_time<Derived, false>
|
---|
| 746 | {
|
---|
| 747 | enum { ret = 0 };
|
---|
| 748 | };
|
---|
| 749 |
|
---|
| 750 | } // end namespace internal
|
---|
| 751 |
|
---|
| 752 | } // end namespace Eigen
|
---|
| 753 |
|
---|
| 754 | #endif // EIGEN_DENSECOEFFSBASE_H
|
---|