Please, help us to better know about our user community by answering the following short survey: https://forms.gle/wpyrxWi18ox9Z5ae9
Eigen  3.4.0
 
Loading...
Searching...
No Matches
Block.h
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
14namespace Eigen {
15
16namespace internal {
17template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
18struct traits<Block<XprType, BlockRows, BlockCols, InnerPanel> > : traits<XprType>
19{
20 typedef typename traits<XprType>::Scalar Scalar;
21 typedef typename traits<XprType>::StorageKind StorageKind;
22 typedef typename traits<XprType>::XprKind XprKind;
23 typedef typename ref_selector<XprType>::type XprTypeNested;
24 typedef typename remove_reference<XprTypeNested>::type _XprTypeNested;
25 enum{
26 MatrixRows = traits<XprType>::RowsAtCompileTime,
27 MatrixCols = traits<XprType>::ColsAtCompileTime,
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
62template<typename XprType, int BlockRows=Dynamic, int BlockCols=Dynamic, bool InnerPanel = false,
63 bool HasDirectAccess = internal::has_direct_access<XprType>::ret> class BlockImpl_dense;
64
65} // end namespace internal
66
67template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, typename StorageKind> class BlockImpl;
68
103template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel> class Block
104 : public BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, typename internal::traits<XprType>::StorageKind>
105{
106 typedef BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, typename internal::traits<XprType>::StorageKind> Impl;
107 public:
108 //typedef typename Impl::Base Base;
109 typedef Impl Base;
110 EIGEN_GENERIC_PUBLIC_INTERFACE(Block)
111 EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Block)
112
113 typedef typename internal::remove_all<XprType>::type NestedExpression;
114
117 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
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
127 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
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
138 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
139 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...
153template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
154class BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, Dense>
155 : public internal::BlockImpl_dense<XprType, BlockRows, BlockCols, InnerPanel>
156{
157 typedef internal::BlockImpl_dense<XprType, BlockRows, BlockCols, InnerPanel> Impl;
158 typedef typename XprType::StorageIndex StorageIndex;
159 public:
160 typedef Impl Base;
161 EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl)
162 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE BlockImpl(XprType& xpr, Index i) : Impl(xpr,i) {}
163 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE BlockImpl(XprType& xpr, Index startRow, Index startCol) : Impl(xpr, startRow, startCol) {}
164 EIGEN_DEVICE_FUNC
165 EIGEN_STRONG_INLINE BlockImpl(XprType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
166 : Impl(xpr, startRow, startCol, blockRows, blockCols) {}
167};
168
169namespace internal {
170
172template<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{
175 typedef Block<XprType, BlockRows, BlockCols, InnerPanel> BlockType;
176 typedef typename internal::ref_selector<XprType>::non_const_type XprTypeNested;
177 public:
178
179 typedef typename internal::dense_xpr_base<BlockType>::type Base;
180 EIGEN_DENSE_PUBLIC_INTERFACE(BlockType)
181 EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl_dense)
182
183 // class InnerIterator; // FIXME apparently never used
184
185
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 {
224 EIGEN_STATIC_ASSERT_LVALUE(XprType)
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 {
243 EIGEN_STATIC_ASSERT_LVALUE(XprType)
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
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 EIGEN_STRONG_INLINE
298 const typename internal::remove_all<XprTypeNested>::type& nestedExpression() const
299 {
300 return m_xpr;
301 }
302
303 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
304 XprType& nestedExpression() { return m_xpr; }
305
306 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
307 StorageIndex startRow() const EIGEN_NOEXCEPT
308 {
309 return m_startRow.value();
310 }
311
312 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
313 StorageIndex startCol() const EIGEN_NOEXCEPT
314 {
315 return m_startCol.value();
316 }
317
318 protected:
319
320 XprTypeNested m_xpr;
321 const internal::variable_if_dynamic<StorageIndex, (XprType::RowsAtCompileTime == 1 && BlockRows==1) ? 0 : Dynamic> m_startRow;
322 const internal::variable_if_dynamic<StorageIndex, (XprType::ColsAtCompileTime == 1 && BlockCols==1) ? 0 : Dynamic> m_startCol;
323 const internal::variable_if_dynamic<StorageIndex, RowsAtCompileTime> m_blockRows;
324 const internal::variable_if_dynamic<StorageIndex, ColsAtCompileTime> m_blockCols;
325};
326
328template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
329class BlockImpl_dense<XprType,BlockRows,BlockCols, InnerPanel,true>
330 : public MapBase<Block<XprType, BlockRows, BlockCols, InnerPanel> >
331{
332 typedef Block<XprType, BlockRows, BlockCols, InnerPanel> BlockType;
333 typedef typename internal::ref_selector<XprType>::non_const_type XprTypeNested;
334 enum {
335 XprTypeIsRowMajor = (int(traits<XprType>::Flags)&RowMajorBit) != 0
336 };
337 public:
338
339 typedef MapBase<BlockType> Base;
340 EIGEN_DENSE_PUBLIC_INTERFACE(BlockType)
341 EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl_dense)
342
343
345 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
346 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 EIGEN_STRONG_INLINE
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
370 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
371 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 EIGEN_STRONG_INLINE
381 const typename internal::remove_all<XprTypeNested>::type& nestedExpression() const EIGEN_NOEXCEPT
382 {
383 return m_xpr;
384 }
385
386 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
387 XprType& nestedExpression() { return m_xpr; }
388
390 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
391 Index innerStride() const EIGEN_NOEXCEPT
392 {
393 return internal::traits<BlockType>::HasSameStorageOrderAsXprType
394 ? m_xpr.innerStride()
395 : m_xpr.outerStride();
396 }
397
399 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
400 Index outerStride() const EIGEN_NOEXCEPT
401 {
402 return internal::traits<BlockType>::HasSameStorageOrderAsXprType
403 ? m_xpr.outerStride()
404 : m_xpr.innerStride();
405 }
406
407 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
408 StorageIndex startRow() const EIGEN_NOEXCEPT { return m_startRow.value(); }
409
410 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
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
421 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
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:
430 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
431 void init()
432 {
433 m_outerStride = internal::traits<BlockType>::HasSameStorageOrderAsXprType
434 ? m_xpr.outerStride()
435 : m_xpr.innerStride();
436 }
437
438 XprTypeNested m_xpr;
439 const internal::variable_if_dynamic<StorageIndex, (XprType::RowsAtCompileTime == 1 && BlockRows==1) ? 0 : Dynamic> m_startRow;
440 const internal::variable_if_dynamic<StorageIndex, (XprType::ColsAtCompileTime == 1 && BlockCols==1) ? 0 : Dynamic> m_startCol;
441 Index m_outerStride;
442};
443
444} // end namespace internal
445
446} // end namespace Eigen
447
448#endif // EIGEN_BLOCK_H
Expression of a fixed-size or dynamic-size block.
Definition: Block.h:105
Block(XprType &xpr, Index startRow, Index startCol)
Definition: Block.h:128
Block(XprType &xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
Definition: Block.h:139
Block(XprType &xpr, Index i)
Definition: Block.h:118
const unsigned int DirectAccessBit
Definition: Constants.h:155
const unsigned int LvalueBit
Definition: Constants.h:144
const unsigned int RowMajorBit
Definition: Constants.h:66
const unsigned int CompressedAccessBit
Definition: Constants.h:191
Namespace containing all symbols from the Eigen library.
Definition: Core:141
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74
const int Dynamic
Definition: Constants.h:22