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
48
49namespace internal {
50template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, bool HasDirectAccess>
51struct traits<Block<XprType, BlockRows, BlockCols, InnerPanel, HasDirectAccess> > : traits<XprType>
52{
53 typedef typename traits<XprType>::Scalar Scalar;
54 typedef typename traits<XprType>::StorageKind StorageKind;
55 typedef typename traits<XprType>::XprKind XprKind;
56 typedef typename nested<XprType>::type XprTypeNested;
57 typedef typename remove_reference<XprTypeNested>::type _XprTypeNested;
58 enum{
59 MatrixRows = traits<XprType>::RowsAtCompileTime,
60 MatrixCols = traits<XprType>::ColsAtCompileTime,
61 RowsAtCompileTime = MatrixRows == 0 ? 0 : BlockRows,
62 ColsAtCompileTime = MatrixCols == 0 ? 0 : BlockCols,
63 MaxRowsAtCompileTime = BlockRows==0 ? 0
64 : RowsAtCompileTime != Dynamic ? int(RowsAtCompileTime)
65 : int(traits<XprType>::MaxRowsAtCompileTime),
66 MaxColsAtCompileTime = BlockCols==0 ? 0
67 : ColsAtCompileTime != Dynamic ? int(ColsAtCompileTime)
68 : int(traits<XprType>::MaxColsAtCompileTime),
69 XprTypeIsRowMajor = (int(traits<XprType>::Flags)&RowMajorBit) != 0,
70 IsRowMajor = (MaxRowsAtCompileTime==1&&MaxColsAtCompileTime!=1) ? 1
71 : (MaxColsAtCompileTime==1&&MaxRowsAtCompileTime!=1) ? 0
72 : XprTypeIsRowMajor,
73 HasSameStorageOrderAsXprType = (IsRowMajor == XprTypeIsRowMajor),
74 InnerSize = IsRowMajor ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
75 InnerStrideAtCompileTime = HasSameStorageOrderAsXprType
76 ? int(inner_stride_at_compile_time<XprType>::ret)
77 : int(outer_stride_at_compile_time<XprType>::ret),
78 OuterStrideAtCompileTime = HasSameStorageOrderAsXprType
79 ? int(outer_stride_at_compile_time<XprType>::ret)
80 : int(inner_stride_at_compile_time<XprType>::ret),
81 MaskPacketAccessBit = (InnerSize == Dynamic || (InnerSize % packet_traits<Scalar>::size) == 0)
82 && (InnerStrideAtCompileTime == 1)
83 ? PacketAccessBit : 0,
84 MaskAlignedBit = (InnerPanel && (OuterStrideAtCompileTime!=Dynamic) && (((OuterStrideAtCompileTime * int(sizeof(Scalar))) % 16) == 0)) ? AlignedBit : 0,
85 FlagsLinearAccessBit = (RowsAtCompileTime == 1 || ColsAtCompileTime == 1) ? LinearAccessBit : 0,
86 FlagsLvalueBit = is_lvalue<XprType>::value ? LvalueBit : 0,
87 FlagsRowMajorBit = IsRowMajor ? RowMajorBit : 0,
88 Flags0 = traits<XprType>::Flags & ( (HereditaryBits & ~RowMajorBit) |
89 DirectAccessBit |
90 MaskPacketAccessBit |
91 MaskAlignedBit),
92 Flags = Flags0 | FlagsLinearAccessBit | FlagsLvalueBit | FlagsRowMajorBit
93 };
94};
95}
96
97template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, bool HasDirectAccess> class Block
98 : public internal::dense_xpr_base<Block<XprType, BlockRows, BlockCols, InnerPanel, HasDirectAccess> >::type
99{
100 public:
101
102 typedef typename internal::dense_xpr_base<Block>::type Base;
103 EIGEN_DENSE_PUBLIC_INTERFACE(Block)
104
105 class InnerIterator;
106
109 inline Block(XprType& xpr, Index i)
110 : m_xpr(xpr),
111 // It is a row if and only if BlockRows==1 and BlockCols==XprType::ColsAtCompileTime,
112 // and it is a column if and only if BlockRows==XprType::RowsAtCompileTime and BlockCols==1,
113 // all other cases are invalid.
114 // The case a 1x1 matrix seems ambiguous, but the result is the same anyway.
115 m_startRow( (BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) ? i : 0),
116 m_startCol( (BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) ? i : 0),
117 m_blockRows(BlockRows==1 ? 1 : xpr.rows()),
118 m_blockCols(BlockCols==1 ? 1 : xpr.cols())
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 inline Block(XprType& xpr, Index startRow, Index startCol)
128 : m_xpr(xpr), m_startRow(startRow), m_startCol(startCol),
129 m_blockRows(BlockRows), m_blockCols(BlockCols)
130 {
131 EIGEN_STATIC_ASSERT(RowsAtCompileTime!=Dynamic && ColsAtCompileTime!=Dynamic,THIS_METHOD_IS_ONLY_FOR_FIXED_SIZE)
132 eigen_assert(startRow >= 0 && BlockRows >= 1 && startRow + BlockRows <= xpr.rows()
133 && startCol >= 0 && BlockCols >= 1 && startCol + BlockCols <= xpr.cols());
134 }
135
138 inline Block(XprType& xpr,
139 Index startRow, Index startCol,
140 Index blockRows, Index blockCols)
141 : m_xpr(xpr), m_startRow(startRow), m_startCol(startCol),
142 m_blockRows(blockRows), m_blockCols(blockCols)
143 {
144 eigen_assert((RowsAtCompileTime==Dynamic || RowsAtCompileTime==blockRows)
145 && (ColsAtCompileTime==Dynamic || ColsAtCompileTime==blockCols));
146 eigen_assert(startRow >= 0 && blockRows >= 0 && startRow + blockRows <= xpr.rows()
147 && startCol >= 0 && blockCols >= 0 && startCol + blockCols <= xpr.cols());
148 }
149
150 EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Block)
151
152 inline Index rows() const { return m_blockRows.value(); }
153 inline Index cols() const { return m_blockCols.value(); }
154
155 inline Scalar& coeffRef(Index row, Index col)
156 {
157 EIGEN_STATIC_ASSERT_LVALUE(XprType)
158 return m_xpr.const_cast_derived()
159 .coeffRef(row + m_startRow.value(), col + m_startCol.value());
160 }
161
162 inline const Scalar& coeffRef(Index row, Index col) const
163 {
164 return m_xpr.derived()
165 .coeffRef(row + m_startRow.value(), col + m_startCol.value());
166 }
167
168 EIGEN_STRONG_INLINE const CoeffReturnType coeff(Index row, Index col) const
169 {
170 return m_xpr.coeff(row + m_startRow.value(), col + m_startCol.value());
171 }
172
173 inline Scalar& coeffRef(Index index)
174 {
175 EIGEN_STATIC_ASSERT_LVALUE(XprType)
176 return m_xpr.const_cast_derived()
177 .coeffRef(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
178 m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
179 }
180
181 inline const Scalar& coeffRef(Index index) const
182 {
183 return m_xpr.const_cast_derived()
184 .coeffRef(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
185 m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
186 }
187
188 inline const CoeffReturnType coeff(Index index) const
189 {
190 return m_xpr
191 .coeff(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
192 m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
193 }
194
195 template<int LoadMode>
196 inline PacketScalar packet(Index row, Index col) const
197 {
198 return m_xpr.template packet<Unaligned>
199 (row + m_startRow.value(), col + m_startCol.value());
200 }
201
202 template<int LoadMode>
203 inline void writePacket(Index row, Index col, const PacketScalar& x)
204 {
205 m_xpr.const_cast_derived().template writePacket<Unaligned>
206 (row + m_startRow.value(), col + m_startCol.value(), x);
207 }
208
209 template<int LoadMode>
210 inline PacketScalar packet(Index index) const
211 {
212 return m_xpr.template packet<Unaligned>
213 (m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
214 m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
215 }
216
217 template<int LoadMode>
218 inline void writePacket(Index index, const PacketScalar& x)
219 {
220 m_xpr.const_cast_derived().template writePacket<Unaligned>
221 (m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
222 m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0), x);
223 }
224
225 #ifdef EIGEN_PARSED_BY_DOXYGEN
227 inline const Scalar* data() const;
228 inline Index innerStride() const;
229 inline Index outerStride() const;
230 #endif
231
232 const typename internal::remove_all<typename XprType::Nested>::type& nestedExpression() const
233 {
234 return m_xpr;
235 }
236
237 Index startRow() const
238 {
239 return m_startRow.value();
240 }
241
242 Index startCol() const
243 {
244 return m_startCol.value();
245 }
246
247 protected:
248
249 const typename XprType::Nested m_xpr;
250 const internal::variable_if_dynamic<Index, XprType::RowsAtCompileTime == 1 ? 0 : Dynamic> m_startRow;
251 const internal::variable_if_dynamic<Index, XprType::ColsAtCompileTime == 1 ? 0 : Dynamic> m_startCol;
252 const internal::variable_if_dynamic<Index, RowsAtCompileTime> m_blockRows;
253 const internal::variable_if_dynamic<Index, ColsAtCompileTime> m_blockCols;
254};
255
257template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
258class Block<XprType,BlockRows,BlockCols, InnerPanel,true>
259 : public MapBase<Block<XprType, BlockRows, BlockCols, InnerPanel, true> >
260{
261 public:
262
263 typedef MapBase<Block> Base;
264 EIGEN_DENSE_PUBLIC_INTERFACE(Block)
265
266 EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Block)
267
268
270 inline Block(XprType& xpr, Index i)
271 : Base(internal::const_cast_ptr(&xpr.coeffRef(
272 (BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) ? i : 0,
273 (BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) ? i : 0)),
274 BlockRows==1 ? 1 : xpr.rows(),
275 BlockCols==1 ? 1 : xpr.cols()),
276 m_xpr(xpr)
277 {
278 eigen_assert( (i>=0) && (
279 ((BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) && i<xpr.rows())
280 ||((BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) && i<xpr.cols())));
281 init();
282 }
283
286 inline Block(XprType& xpr, Index startRow, Index startCol)
287 : Base(internal::const_cast_ptr(&xpr.coeffRef(startRow,startCol))), m_xpr(xpr)
288 {
289 eigen_assert(startRow >= 0 && BlockRows >= 1 && startRow + BlockRows <= xpr.rows()
290 && startCol >= 0 && BlockCols >= 1 && startCol + BlockCols <= xpr.cols());
291 init();
292 }
293
296 inline Block(XprType& xpr,
297 Index startRow, Index startCol,
298 Index blockRows, Index blockCols)
299 : Base(internal::const_cast_ptr(&xpr.coeffRef(startRow,startCol)), blockRows, blockCols),
300 m_xpr(xpr)
301 {
302 eigen_assert((RowsAtCompileTime==Dynamic || RowsAtCompileTime==blockRows)
303 && (ColsAtCompileTime==Dynamic || ColsAtCompileTime==blockCols));
304 eigen_assert(startRow >= 0 && blockRows >= 0 && startRow + blockRows <= xpr.rows()
305 && startCol >= 0 && blockCols >= 0 && startCol + blockCols <= xpr.cols());
306 init();
307 }
308
309 const typename internal::remove_all<typename XprType::Nested>::type& nestedExpression() const
310 {
311 return m_xpr;
312 }
313
315 inline Index innerStride() const
316 {
317 return internal::traits<Block>::HasSameStorageOrderAsXprType
318 ? m_xpr.innerStride()
319 : m_xpr.outerStride();
320 }
321
323 inline Index outerStride() const
324 {
325 return m_outerStride;
326 }
327
328 #ifndef __SUNPRO_CC
329 // FIXME sunstudio is not friendly with the above friend...
330 // META-FIXME there is no 'friend' keyword around here. Is this obsolete?
331 protected:
332 #endif
333
334 #ifndef EIGEN_PARSED_BY_DOXYGEN
336 inline Block(XprType& xpr, const Scalar* data, Index blockRows, Index blockCols)
337 : Base(data, blockRows, blockCols), m_xpr(xpr)
338 {
339 init();
340 }
341 #endif
342
343 protected:
344 void init()
345 {
346 m_outerStride = internal::traits<Block>::HasSameStorageOrderAsXprType
347 ? m_xpr.outerStride()
348 : m_xpr.innerStride();
349 }
350
351 typename XprType::Nested m_xpr;
352 Index m_outerStride;
353};
354
355} // end namespace Eigen
356
357#endif // EIGEN_BLOCK_H
Eigen::Block
Expression of a fixed-size or dynamic-size block.
Definition Block.h:99
Eigen::Block::data
const Scalar * data() const
Eigen::Block::Block
Block(XprType &xpr, Index i)
Definition Block.h:109
Eigen::Block::Block
Block(XprType &xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
Definition Block.h:138
Eigen::Block::Block
Block(XprType &xpr, Index startRow, Index startCol)
Definition Block.h:127
Eigen::DirectAccessBit
const unsigned int DirectAccessBit
Definition Constants.h:137
Eigen::LvalueBit
const unsigned int LvalueBit
Definition Constants.h:126
Eigen::RowMajorBit
const unsigned int RowMajorBit
Definition Constants.h:48
Eigen::AlignedBit
const unsigned int AlignedBit
Definition Constants.h:142
Eigen::PacketAccessBit
const unsigned int PacketAccessBit
Definition Constants.h:76
Eigen::LinearAccessBit
const unsigned int LinearAccessBit
Definition Constants.h:112
Eigen::internal
Definition LDLT.h:18