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
69/** \class Block
70  * \ingroup Core_Module
71  *
72  * \brief Expression of a fixed-size or dynamic-size block
73  *
74  * \tparam XprType the type of the expression in which we are taking a block
75  * \tparam BlockRows the number of rows of the block we are taking at compile time (optional)
76  * \tparam BlockCols the number of columns of the block we are taking at compile time (optional)
77  * \tparam InnerPanel is true, if the block maps to a set of rows of a row major matrix or
78  *         to set of columns of a column major matrix (optional). The parameter allows to determine
79  *         at compile time whether aligned access is possible on the block expression.
80  *
81  * This class represents an expression of either a fixed-size or dynamic-size block. It is the return
82  * type of DenseBase::block(Index,Index,Index,Index) and DenseBase::block<int,int>(Index,Index) and
83  * most of the time this is the only way it is used.
84  *
85  * However, if you want to directly maniputate block expressions,
86  * for instance if you want to write a function returning such an expression, you
87  * will need to use this class.
88  *
89  * Here is an example illustrating the dynamic case:
90  * \include class_Block.cpp
91  * Output: \verbinclude class_Block.out
92  *
93  * \note Even though this expression has dynamic size, in the case where \a XprType
94  * has fixed size, this expression inherits a fixed maximal size which means that evaluating
95  * it does not cause a dynamic memory allocation.
96  *
97  * Here is an example illustrating the fixed-size case:
98  * \include class_FixedBlock.cpp
99  * Output: \verbinclude class_FixedBlock.out
100  *
101  * \sa DenseBase::block(Index,Index,Index,Index), DenseBase::block(Index,Index), class VectorBlock
102  */
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
115    /** Column or Row constructor
116      */
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
125    /** Fixed-size constructor
126      */
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
136    /** Dynamic-size constructor
137      */
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...
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 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
169namespace internal {
170
171/** \internal Internal implementation of dense Blocks in the general case. */
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    /** Column or Row constructor
186      */
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
200    /** Fixed-size constructor
201      */
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
208    /** Dynamic-size constructor
209      */
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
291    /** \sa MapBase::data() */
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
298    const typename internal::remove_all<XprTypeNested>::type& nestedExpression() const
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;
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
327/** \internal Internal implementation of dense Blocks in the direct access case.*/
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    /** Column or Row constructor
344      */
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
358    /** Fixed-size constructor
359      */
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
368    /** Dynamic-size constructor
369      */
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
381    const typename internal::remove_all<XprTypeNested>::type& nestedExpression() const
382    {
383      return m_xpr;
384    }
385
386    EIGEN_DEVICE_FUNC
387    XprType& nestedExpression() { return m_xpr; }
388
389    /** \sa MapBase::innerStride() */
390    EIGEN_DEVICE_FUNC
391    inline Index innerStride() const
392    {
393      return internal::traits<BlockType>::HasSameStorageOrderAsXprType
394             ? m_xpr.innerStride()
395             : m_xpr.outerStride();
396    }
397
398    /** \sa MapBase::outerStride() */
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    /** \internal used by allowAligned() */
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    {
437      m_outerStride = internal::traits<BlockType>::HasSameStorageOrderAsXprType
438                    ? m_xpr.outerStride()
439                    : m_xpr.innerStride();
440    }
441
442    XprTypeNested m_xpr;
443    const internal::variable_if_dynamic<StorageIndex, (XprType::RowsAtCompileTime == 1 && BlockRows==1) ? 0 : Dynamic> m_startRow;
444    const internal::variable_if_dynamic<StorageIndex, (XprType::ColsAtCompileTime == 1 && BlockCols==1) ? 0 : Dynamic> m_startCol;
445    Index m_outerStride;
446};
447
448} // end namespace internal
449
450} // end namespace Eigen
451
452#endif // EIGEN_BLOCK_H
453