Block.h
Go to the documentation of this file.
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
5 // Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@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_BLOCK_H
12 #define EIGEN_BLOCK_H
13 
14 namespace Eigen {
15 
16 namespace internal {
17 template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
18 struct traits<Block<XprType, BlockRows, BlockCols, InnerPanel> > : traits<XprType>
19 {
20  typedef typename traits<XprType>::Scalar Scalar;
25  enum{
28  RowsAtCompileTime = MatrixRows == 0 ? 0 : BlockRows,
29  ColsAtCompileTime = MatrixCols == 0 ? 0 : BlockCols,
30  MaxRowsAtCompileTime = BlockRows==0 ? 0
31  : RowsAtCompileTime != Dynamic ? int(RowsAtCompileTime)
32  : int(traits<XprType>::MaxRowsAtCompileTime),
33  MaxColsAtCompileTime = BlockCols==0 ? 0
34  : ColsAtCompileTime != Dynamic ? int(ColsAtCompileTime)
35  : int(traits<XprType>::MaxColsAtCompileTime),
36 
37  XprTypeIsRowMajor = (int(traits<XprType>::Flags)&RowMajorBit) != 0,
38  IsRowMajor = (MaxRowsAtCompileTime==1&&MaxColsAtCompileTime!=1) ? 1
39  : (MaxColsAtCompileTime==1&&MaxRowsAtCompileTime!=1) ? 0
40  : XprTypeIsRowMajor,
41  HasSameStorageOrderAsXprType = (IsRowMajor == XprTypeIsRowMajor),
42  InnerSize = IsRowMajor ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
43  InnerStrideAtCompileTime = HasSameStorageOrderAsXprType
46  OuterStrideAtCompileTime = HasSameStorageOrderAsXprType
49 
50  // FIXME, this traits is rather specialized for dense object and it needs to be cleaned further
51  FlagsLvalueBit = is_lvalue<XprType>::value ? LvalueBit : 0,
52  FlagsRowMajorBit = IsRowMajor ? RowMajorBit : 0,
53  Flags = (traits<XprType>::Flags & (DirectAccessBit | (InnerPanel?CompressedAccessBit:0))) | FlagsLvalueBit | FlagsRowMajorBit,
54  // FIXME DirectAccessBit should not be handled by expressions
55  //
56  // Alignment is needed by MapBase's assertions
57  // We can sefely set it to false here. Internal alignment errors will be detected by an eigen_internal_assert in the respective evaluator
58  Alignment = 0
59  };
60 };
61 
62 template<typename XprType, int BlockRows=Dynamic, int BlockCols=Dynamic, bool InnerPanel = false,
64 
65 } // end namespace internal
66 
67 template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, typename StorageKind> class BlockImpl;
68 
103 template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel> class Block
104  : public BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, typename internal::traits<XprType>::StorageKind>
105 {
107  public:
108  //typedef typename Impl::Base Base;
109  typedef Impl Base;
112 
113  typedef typename internal::remove_all<XprType>::type NestedExpression;
114 
118  Block(XprType& xpr, Index i) : Impl(xpr,i)
119  {
120  eigen_assert( (i>=0) && (
121  ((BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) && i<xpr.rows())
122  ||((BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) && i<xpr.cols())));
123  }
124 
128  Block(XprType& xpr, Index startRow, Index startCol)
129  : Impl(xpr, startRow, startCol)
130  {
131  EIGEN_STATIC_ASSERT(RowsAtCompileTime!=Dynamic && ColsAtCompileTime!=Dynamic,THIS_METHOD_IS_ONLY_FOR_FIXED_SIZE)
132  eigen_assert(startRow >= 0 && BlockRows >= 0 && startRow + BlockRows <= xpr.rows()
133  && startCol >= 0 && BlockCols >= 0 && startCol + BlockCols <= xpr.cols());
134  }
135 
140  Index startRow, Index startCol,
141  Index blockRows, Index blockCols)
142  : Impl(xpr, startRow, startCol, blockRows, blockCols)
143  {
144  eigen_assert((RowsAtCompileTime==Dynamic || RowsAtCompileTime==blockRows)
145  && (ColsAtCompileTime==Dynamic || ColsAtCompileTime==blockCols));
146  eigen_assert(startRow >= 0 && blockRows >= 0 && startRow <= xpr.rows() - blockRows
147  && startCol >= 0 && blockCols >= 0 && startCol <= xpr.cols() - blockCols);
148  }
149 };
150 
151 // The generic default implementation for dense block simplu forward to the internal::BlockImpl_dense
152 // that must be specialized for direct and non-direct access...
153 template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
154 class BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, Dense>
155  : public internal::BlockImpl_dense<XprType, BlockRows, BlockCols, InnerPanel>
156 {
158  typedef typename XprType::StorageIndex StorageIndex;
159  public:
160  typedef Impl Base;
163  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE BlockImpl(XprType& xpr, Index startRow, Index startCol) : Impl(xpr, startRow, startCol) {}
165  EIGEN_STRONG_INLINE BlockImpl(XprType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
166  : Impl(xpr, startRow, startCol, blockRows, blockCols) {}
167 };
168 
169 namespace internal {
170 
172 template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, bool HasDirectAccess> class BlockImpl_dense
173  : public internal::dense_xpr_base<Block<XprType, BlockRows, BlockCols, InnerPanel> >::type
174 {
177  public:
178 
182 
183  // class InnerIterator; // FIXME apparently never used
184 
185 
189  : m_xpr(xpr),
190  // It is a row if and only if BlockRows==1 and BlockCols==XprType::ColsAtCompileTime,
191  // and it is a column if and only if BlockRows==XprType::RowsAtCompileTime and BlockCols==1,
192  // all other cases are invalid.
193  // The case a 1x1 matrix seems ambiguous, but the result is the same anyway.
194  m_startRow( (BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) ? i : 0),
195  m_startCol( (BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) ? i : 0),
196  m_blockRows(BlockRows==1 ? 1 : xpr.rows()),
197  m_blockCols(BlockCols==1 ? 1 : xpr.cols())
198  {}
199 
203  inline BlockImpl_dense(XprType& xpr, Index startRow, Index startCol)
204  : m_xpr(xpr), m_startRow(startRow), m_startCol(startCol),
205  m_blockRows(BlockRows), m_blockCols(BlockCols)
206  {}
207 
212  Index startRow, Index startCol,
213  Index blockRows, Index blockCols)
214  : m_xpr(xpr), m_startRow(startRow), m_startCol(startCol),
215  m_blockRows(blockRows), m_blockCols(blockCols)
216  {}
217 
218  EIGEN_DEVICE_FUNC inline Index rows() const { return m_blockRows.value(); }
219  EIGEN_DEVICE_FUNC inline Index cols() const { return m_blockCols.value(); }
220 
222  inline Scalar& coeffRef(Index rowId, Index colId)
223  {
225  return m_xpr.coeffRef(rowId + m_startRow.value(), colId + m_startCol.value());
226  }
227 
229  inline const Scalar& coeffRef(Index rowId, Index colId) const
230  {
231  return m_xpr.derived().coeffRef(rowId + m_startRow.value(), colId + m_startCol.value());
232  }
233 
235  EIGEN_STRONG_INLINE const CoeffReturnType coeff(Index rowId, Index colId) const
236  {
237  return m_xpr.coeff(rowId + m_startRow.value(), colId + m_startCol.value());
238  }
239 
241  inline Scalar& coeffRef(Index index)
242  {
244  return m_xpr.coeffRef(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
245  m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
246  }
247 
249  inline const Scalar& coeffRef(Index index) const
250  {
251  return m_xpr.coeffRef(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
252  m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
253  }
254 
256  inline const CoeffReturnType coeff(Index index) const
257  {
258  return m_xpr.coeff(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
259  m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
260  }
261 
262  template<int LoadMode>
263  inline PacketScalar packet(Index rowId, Index colId) const
264  {
265  return m_xpr.template packet<Unaligned>(rowId + m_startRow.value(), colId + m_startCol.value());
266  }
267 
268  template<int LoadMode>
269  inline void writePacket(Index rowId, Index colId, const PacketScalar& val)
270  {
271  m_xpr.template writePacket<Unaligned>(rowId + m_startRow.value(), colId + m_startCol.value(), val);
272  }
273 
274  template<int LoadMode>
275  inline PacketScalar packet(Index index) const
276  {
277  return m_xpr.template packet<Unaligned>
278  (m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
279  m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
280  }
281 
282  template<int LoadMode>
283  inline void writePacket(Index index, const PacketScalar& val)
284  {
285  m_xpr.template writePacket<Unaligned>
286  (m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
287  m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0), val);
288  }
289 
290  #ifdef EIGEN_PARSED_BY_DOXYGEN
291 
292  EIGEN_DEVICE_FUNC inline const Scalar* data() const;
293  EIGEN_DEVICE_FUNC inline Index innerStride() const;
294  EIGEN_DEVICE_FUNC inline Index outerStride() const;
295  #endif
296 
299  {
300  return m_xpr;
301  }
302 
304  XprType& nestedExpression() { return m_xpr; }
305 
307  StorageIndex startRow() const EIGEN_NOEXCEPT
308  {
309  return m_startRow.value();
310  }
311 
313  StorageIndex startCol() const EIGEN_NOEXCEPT
314  {
315  return m_startCol.value();
316  }
317 
318  protected:
319 
320  XprTypeNested m_xpr;
325 };
326 
328 template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
329 class BlockImpl_dense<XprType,BlockRows,BlockCols, InnerPanel,true>
330  : public MapBase<Block<XprType, BlockRows, BlockCols, InnerPanel> >
331 {
334  enum {
335  XprTypeIsRowMajor = (int(traits<XprType>::Flags)&RowMajorBit) != 0
336  };
337  public:
338 
342 
343 
347  : Base(xpr.data() + i * ( ((BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) && (!XprTypeIsRowMajor))
348  || ((BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) && ( XprTypeIsRowMajor)) ? xpr.innerStride() : xpr.outerStride()),
349  BlockRows==1 ? 1 : xpr.rows(),
350  BlockCols==1 ? 1 : xpr.cols()),
351  m_xpr(xpr),
352  m_startRow( (BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) ? i : 0),
353  m_startCol( (BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) ? i : 0)
354  {
355  init();
356  }
357 
361  BlockImpl_dense(XprType& xpr, Index startRow, Index startCol)
362  : Base(xpr.data()+xpr.innerStride()*(XprTypeIsRowMajor?startCol:startRow) + xpr.outerStride()*(XprTypeIsRowMajor?startRow:startCol)),
363  m_xpr(xpr), m_startRow(startRow), m_startCol(startCol)
364  {
365  init();
366  }
367 
372  Index startRow, Index startCol,
373  Index blockRows, Index blockCols)
374  : Base(xpr.data()+xpr.innerStride()*(XprTypeIsRowMajor?startCol:startRow) + xpr.outerStride()*(XprTypeIsRowMajor?startRow:startCol), blockRows, blockCols),
375  m_xpr(xpr), m_startRow(startRow), m_startCol(startCol)
376  {
377  init();
378  }
379 
382  {
383  return m_xpr;
384  }
385 
387  XprType& nestedExpression() { return m_xpr; }
388 
392  {
394  ? m_xpr.innerStride()
395  : m_xpr.outerStride();
396  }
397 
401  {
403  ? m_xpr.outerStride()
404  : m_xpr.innerStride();
405  }
406 
408  StorageIndex startRow() const EIGEN_NOEXCEPT { return m_startRow.value(); }
409 
411  StorageIndex startCol() const EIGEN_NOEXCEPT { return m_startCol.value(); }
412 
413  #ifndef __SUNPRO_CC
414  // FIXME sunstudio is not friendly with the above friend...
415  // META-FIXME there is no 'friend' keyword around here. Is this obsolete?
416  protected:
417  #endif
418 
419  #ifndef EIGEN_PARSED_BY_DOXYGEN
420 
422  BlockImpl_dense(XprType& xpr, const Scalar* data, Index blockRows, Index blockCols)
423  : Base(data, blockRows, blockCols), m_xpr(xpr)
424  {
425  init();
426  }
427  #endif
428 
429  protected:
431  void init()
432  {
434  ? m_xpr.outerStride()
435  : m_xpr.innerStride();
436  }
437 
438  XprTypeNested m_xpr;
442 };
443 
444 } // end namespace internal
445 
446 } // end namespace Eigen
447 
448 #endif // EIGEN_BLOCK_H
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const CoeffReturnType coeff(Index rowId, Index colId) const
Definition: Block.h:235
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE BlockImpl(XprType &xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
Definition: Block.h:165
#define EIGEN_GENERIC_PUBLIC_INTERFACE(Derived)
Definition: Macros.h:1264
#define EIGEN_STRONG_INLINE
Definition: Macros.h:917
EIGEN_DEVICE_FUNC Scalar & coeffRef(Index rowId, Index colId)
Definition: Block.h:222
internal::BlockImpl_dense< XprType, BlockRows, BlockCols, InnerPanel > Impl
Definition: Block.h:157
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR StorageIndex startRow() const EIGEN_NOEXCEPT
Definition: Block.h:307
const unsigned int CompressedAccessBit
Definition: Constants.h:191
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE XprType & nestedExpression()
Definition: Block.h:304
internal::ref_selector< XprType >::non_const_type XprTypeNested
Definition: Block.h:333
const unsigned int DirectAccessBit
Definition: Constants.h:155
const unsigned int LvalueBit
Definition: Constants.h:144
Namespace containing all symbols from the Eigen library.
Definition: jet.h:637
Block< XprType, BlockRows, BlockCols, InnerPanel > BlockType
Definition: Block.h:332
#define EIGEN_STATIC_ASSERT(CONDITION, MSG)
Definition: StaticAssert.h:127
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE XprType & nestedExpression()
Definition: Block.h:387
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR StorageIndex startCol() const EIGEN_NOEXCEPT
Definition: Block.h:411
const unsigned int RowMajorBit
Definition: Constants.h:66
#define EIGEN_STATIC_ASSERT_LVALUE(Derived)
Definition: StaticAssert.h:202
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE BlockImpl_dense(XprType &xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
Definition: Block.h:371
void writePacket(Index rowId, Index colId, const PacketScalar &val)
Definition: Block.h:269
EIGEN_DEVICE_FUNC BlockImpl_dense(XprType &xpr, Index startRow, Index startCol)
Definition: Block.h:203
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR Index outerStride() const EIGEN_NOEXCEPT
Definition: Block.h:400
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Block(XprType &xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
Definition: Block.h:139
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR StorageIndex startRow() const EIGEN_NOEXCEPT
Definition: Block.h:408
void writePacket(Index index, const PacketScalar &val)
Definition: Block.h:283
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE BlockImpl_dense(XprType &xpr, const Scalar *data, Index blockRows, Index blockCols)
Definition: Block.h:422
const internal::variable_if_dynamic< StorageIndex,(XprType::RowsAtCompileTime==1 &&BlockRows==1) ? 0 :Dynamic > m_startRow
Definition: Block.h:321
#define EIGEN_NOEXCEPT
Definition: Macros.h:1418
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Block(XprType &xpr, Index startRow, Index startCol)
Definition: Block.h:128
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74
#define eigen_assert(x)
Definition: Macros.h:1037
Block< XprType, BlockRows, BlockCols, InnerPanel > BlockType
Definition: Block.h:175
int data[]
#define EIGEN_CONSTEXPR
Definition: Macros.h:787
#define EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Derived)
Definition: Macros.h:1231
EIGEN_DEVICE_FUNC Index cols() const
Definition: Block.h:219
EIGEN_DEVICE_FUNC const Scalar & coeffRef(Index index) const
Definition: Block.h:249
EIGEN_DEVICE_FUNC Scalar & coeffRef(Index index)
Definition: Block.h:241
internal::dense_xpr_base< BlockType >::type Base
Definition: Block.h:179
DenseIndex ret
const internal::variable_if_dynamic< StorageIndex, ColsAtCompileTime > m_blockCols
Definition: Block.h:324
EIGEN_DEVICE_FUNC BlockImpl_dense(XprType &xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
Definition: Block.h:211
#define EIGEN_DEVICE_FUNC
Definition: Macros.h:976
EIGEN_DEVICE_FUNC Index rows() const
Definition: Block.h:218
const internal::variable_if_dynamic< StorageIndex, RowsAtCompileTime > m_blockRows
Definition: Block.h:323
Expression of a fixed-size or dynamic-size block.
Definition: Block.h:103
CwiseBinaryOp< internal::scalar_sum_op< double, double >, const CpyMatrixXd, const CpyMatrixXd > XprType
Definition: nestbyvalue.cpp:15
const internal::variable_if_dynamic< StorageIndex,(XprType::RowsAtCompileTime==1 &&BlockRows==1) ? 0 :Dynamic > m_startRow
Definition: Block.h:439
PacketScalar packet(Index index) const
Definition: Block.h:275
detail::initimpl::constructor< Args... > init()
Binds an existing constructor taking arguments Args...
Definition: pybind11.h:1882
BlockImpl< XprType, BlockRows, BlockCols, InnerPanel, typename internal::traits< XprType >::StorageKind > Impl
Definition: Block.h:106
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const internal::remove_all< XprTypeNested >::type & nestedExpression() const
Definition: Block.h:298
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR Index innerStride() const EIGEN_NOEXCEPT
Definition: Block.h:391
#define EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
Definition: Macros.h:1283
PacketScalar packet(Index rowId, Index colId) const
Definition: Block.h:263
const internal::variable_if_dynamic< StorageIndex,(XprType::ColsAtCompileTime==1 &&BlockCols==1) ? 0 :Dynamic > m_startCol
Definition: Block.h:322
const internal::variable_if_dynamic< StorageIndex,(XprType::ColsAtCompileTime==1 &&BlockCols==1) ? 0 :Dynamic > m_startCol
Definition: Block.h:440
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE BlockImpl_dense(XprType &xpr, Index startRow, Index startCol)
Definition: Block.h:361
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const internal::remove_all< XprTypeNested >::type & nestedExpression() const EIGEN_NOEXCEPT
Definition: Block.h:381
EIGEN_DEVICE_FUNC BlockImpl_dense(XprType &xpr, Index i)
Definition: Block.h:188
const int Dynamic
Definition: Constants.h:22
Generic expression where a coefficient-wise unary operator is applied to an expression.
Definition: CwiseUnaryOp.h:55
EIGEN_DEVICE_FUNC const CoeffReturnType coeff(Index index) const
Definition: Block.h:256
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE BlockImpl(XprType &xpr, Index startRow, Index startCol)
Definition: Block.h:163
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE BlockImpl_dense(XprType &xpr, Index i)
Definition: Block.h:346
internal::ref_selector< XprType >::non_const_type XprTypeNested
Definition: Block.h:176
Definition: pytypes.h:1370
EIGEN_DEVICE_FUNC const Scalar & coeffRef(Index rowId, Index colId) const
Definition: Block.h:229
Impl Base
Definition: Block.h:109
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR StorageIndex startCol() const EIGEN_NOEXCEPT
Definition: Block.h:313


gtsam
Author(s):
autogenerated on Tue Jul 4 2023 02:33:59