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
44  ? int(inner_stride_at_compile_time<XprType>::ret)
45  : int(outer_stride_at_compile_time<XprType>::ret),
46  OuterStrideAtCompileTime = HasSameStorageOrderAsXprType
47  ? int(outer_stride_at_compile_time<XprType>::ret)
48  : int(inner_stride_at_compile_time<XprType>::ret),
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 
117  EIGEN_DEVICE_FUNC
118  inline 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 
127  EIGEN_DEVICE_FUNC
128  inline 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 
138  EIGEN_DEVICE_FUNC
139  inline Block(XprType& xpr,
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;
162  EIGEN_DEVICE_FUNC inline BlockImpl(XprType& xpr, Index i) : Impl(xpr,i) {}
163  EIGEN_DEVICE_FUNC inline BlockImpl(XprType& xpr, Index startRow, Index startCol) : Impl(xpr, startRow, startCol) {}
164  EIGEN_DEVICE_FUNC
165  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 
187  EIGEN_DEVICE_FUNC
188  inline BlockImpl_dense(XprType& xpr, Index i)
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 
202  EIGEN_DEVICE_FUNC
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 
210  EIGEN_DEVICE_FUNC
211  inline BlockImpl_dense(XprType& xpr,
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 
221  EIGEN_DEVICE_FUNC
222  inline Scalar& coeffRef(Index rowId, Index colId)
223  {
225  return m_xpr.coeffRef(rowId + m_startRow.value(), colId + m_startCol.value());
226  }
227 
228  EIGEN_DEVICE_FUNC
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 
234  EIGEN_DEVICE_FUNC
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 
240  EIGEN_DEVICE_FUNC
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 
248  EIGEN_DEVICE_FUNC
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 
255  EIGEN_DEVICE_FUNC
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 
297  EIGEN_DEVICE_FUNC
299  {
300  return m_xpr;
301  }
302 
303  EIGEN_DEVICE_FUNC
304  XprType& nestedExpression() { return m_xpr; }
305 
306  EIGEN_DEVICE_FUNC
307  StorageIndex startRow() const
308  {
309  return m_startRow.value();
310  }
311 
312  EIGEN_DEVICE_FUNC
313  StorageIndex startCol() const
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 
345  EIGEN_DEVICE_FUNC
346  inline BlockImpl_dense(XprType& xpr, Index i)
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 
360  EIGEN_DEVICE_FUNC
361  inline 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 
370  EIGEN_DEVICE_FUNC
371  inline BlockImpl_dense(XprType& xpr,
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 
380  EIGEN_DEVICE_FUNC
382  {
383  return m_xpr;
384  }
385 
386  EIGEN_DEVICE_FUNC
387  XprType& nestedExpression() { return m_xpr; }
388 
390  EIGEN_DEVICE_FUNC
391  inline Index innerStride() const
392  {
394  ? m_xpr.innerStride()
395  : m_xpr.outerStride();
396  }
397 
399  EIGEN_DEVICE_FUNC
400  inline Index outerStride() const
401  {
402  return m_outerStride;
403  }
404 
405  EIGEN_DEVICE_FUNC
406  StorageIndex startRow() const
407  {
408  return m_startRow.value();
409  }
410 
411  EIGEN_DEVICE_FUNC
412  StorageIndex startCol() const
413  {
414  return m_startCol.value();
415  }
416 
417  #ifndef __SUNPRO_CC
418  // FIXME sunstudio is not friendly with the above friend...
419  // META-FIXME there is no 'friend' keyword around here. Is this obsolete?
420  protected:
421  #endif
422 
423  #ifndef EIGEN_PARSED_BY_DOXYGEN
424 
425  EIGEN_DEVICE_FUNC
426  inline BlockImpl_dense(XprType& xpr, const Scalar* data, Index blockRows, Index blockCols)
427  : Base(data, blockRows, blockCols), m_xpr(xpr)
428  {
429  init();
430  }
431  #endif
432 
433  protected:
434  EIGEN_DEVICE_FUNC
435  void init()
436  {
438  ? m_xpr.outerStride()
439  : m_xpr.innerStride();
440  }
441 
442  XprTypeNested m_xpr;
446 };
447 
448 } // end namespace internal
449 
450 } // end namespace Eigen
451 
452 #endif // EIGEN_BLOCK_H
EIGEN_DEVICE_FUNC const Scalar & coeffRef(Index rowId, Index colId) const
Definition: Block.h:229
EIGEN_DEVICE_FUNC Index cols() const
Definition: Block.h:219
#define EIGEN_GENERIC_PUBLIC_INTERFACE(Derived)
Definition: Macros.h:852
#define EIGEN_STRONG_INLINE
Definition: Macros.h:494
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
const unsigned int CompressedAccessBit
Definition: Constants.h:186
return int(ret)+1
EIGEN_DEVICE_FUNC const internal::remove_all< XprTypeNested >::type & nestedExpression() const
Definition: Block.h:298
internal::ref_selector< XprType >::non_const_type XprTypeNested
Definition: Block.h:333
EIGEN_DEVICE_FUNC const CoeffReturnType coeff(Index index) const
Definition: Block.h:256
const unsigned int DirectAccessBit
Definition: Constants.h:150
EIGEN_DEVICE_FUNC XprType & nestedExpression()
Definition: Block.h:304
const unsigned int LvalueBit
Definition: Constants.h:139
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:124
const unsigned int RowMajorBit
Definition: Constants.h:61
#define EIGEN_STATIC_ASSERT_LVALUE(Derived)
Definition: StaticAssert.h:199
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
void writePacket(Index index, const PacketScalar &val)
Definition: Block.h:283
EIGEN_DEVICE_FUNC Block(XprType &xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
Definition: Block.h:139
const internal::variable_if_dynamic< StorageIndex,(XprType::RowsAtCompileTime==1 &&BlockRows==1)?0:Dynamic > m_startRow
Definition: Block.h:321
EIGEN_DEVICE_FUNC BlockImpl_dense(XprType &xpr, Index startRow, Index startCol)
Definition: Block.h:361
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:33
#define eigen_assert(x)
Definition: Macros.h:579
Block< XprType, BlockRows, BlockCols, InnerPanel > BlockType
Definition: Block.h:175
int data[]
PacketScalar packet(Index index) const
Definition: Block.h:275
#define EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Derived)
Definition: Macros.h:842
EIGEN_DEVICE_FUNC Scalar & coeffRef(Index index)
Definition: Block.h:241
EIGEN_DEVICE_FUNC BlockImpl_dense(XprType &xpr, const Scalar *data, Index blockRows, Index blockCols)
Definition: Block.h:426
EIGEN_DEVICE_FUNC BlockImpl_dense(XprType &xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
Definition: Block.h:371
internal::dense_xpr_base< BlockType >::type Base
Definition: Block.h:179
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
EIGEN_DEVICE_FUNC Block(XprType &xpr, Index startRow, Index startCol)
Definition: Block.h:128
const internal::variable_if_dynamic< StorageIndex, RowsAtCompileTime > m_blockRows
Definition: Block.h:323
EIGEN_DEVICE_FUNC StorageIndex startCol() const
Definition: Block.h:313
EIGEN_DEVICE_FUNC StorageIndex startRow() const
Definition: Block.h:307
Expression of a fixed-size or dynamic-size block.
Definition: Block.h:103
const internal::variable_if_dynamic< StorageIndex,(XprType::RowsAtCompileTime==1 &&BlockRows==1)?0:Dynamic > m_startRow
Definition: Block.h:443
DenseIndex ret
Definition: level1_impl.h:59
detail::initimpl::constructor< Args... > init()
Binds an existing constructor taking arguments Args...
Definition: pybind11.h:1460
BlockImpl< XprType, BlockRows, BlockCols, InnerPanel, typename internal::traits< XprType >::StorageKind > Impl
Definition: Block.h:106
EIGEN_DEVICE_FUNC Index rows() const
Definition: Block.h:218
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const CoeffReturnType coeff(Index rowId, Index colId) const
Definition: Block.h:235
#define EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
Definition: Macros.h:870
EIGEN_DEVICE_FUNC BlockImpl(XprType &xpr, Index startRow, Index startCol)
Definition: Block.h:163
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:444
EIGEN_DEVICE_FUNC const Scalar & coeffRef(Index index) const
Definition: Block.h:249
const int Dynamic
Definition: Constants.h:21
PacketScalar packet(Index rowId, Index colId) const
Definition: Block.h:263
EIGEN_DEVICE_FUNC BlockImpl(XprType &xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
Definition: Block.h:165
internal::ref_selector< XprType >::non_const_type XprTypeNested
Definition: Block.h:176
Definition: pytypes.h:897
EIGEN_DEVICE_FUNC const internal::remove_all< XprTypeNested >::type & nestedExpression() const
Definition: Block.h:381
Impl Base
Definition: Block.h:109


gtsam
Author(s):
autogenerated on Sat May 8 2021 02:41:43