Cycles: svn merge -r41225:41232 ^/trunk/blender
[blender.git] / extern / Eigen2 / Eigen / src / Core / Minor.h
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra. Eigen itself is part of the KDE project.
3 //
4 // Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
5 //
6 // Eigen is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 3 of the License, or (at your option) any later version.
10 //
11 // Alternatively, you can redistribute it and/or
12 // modify it under the terms of the GNU General Public License as
13 // published by the Free Software Foundation; either version 2 of
14 // the License, or (at your option) any later version.
15 //
16 // Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
17 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
18 // FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
19 // GNU General Public License for more details.
20 //
21 // You should have received a copy of the GNU Lesser General Public
22 // License and a copy of the GNU General Public License along with
23 // Eigen. If not, see <http://www.gnu.org/licenses/>.
24
25 #ifndef EIGEN_MINOR_H
26 #define EIGEN_MINOR_H
27
28 /** \nonstableyet 
29   * \class Minor
30   *
31   * \brief Expression of a minor
32   *
33   * \param MatrixType the type of the object in which we are taking a minor
34   *
35   * This class represents an expression of a minor. It is the return
36   * type of MatrixBase::minor() and most of the time this is the only way it
37   * is used.
38   *
39   * \sa MatrixBase::minor()
40   */
41 template<typename MatrixType>
42 struct ei_traits<Minor<MatrixType> >
43 {
44   typedef typename MatrixType::Scalar Scalar;
45   typedef typename ei_nested<MatrixType>::type MatrixTypeNested;
46   typedef typename ei_unref<MatrixTypeNested>::type _MatrixTypeNested;
47   enum {
48     RowsAtCompileTime = (MatrixType::RowsAtCompileTime != Dynamic) ?
49                           int(MatrixType::RowsAtCompileTime) - 1 : Dynamic,
50     ColsAtCompileTime = (MatrixType::ColsAtCompileTime != Dynamic) ?
51                           int(MatrixType::ColsAtCompileTime) - 1 : Dynamic,
52     MaxRowsAtCompileTime = (MatrixType::MaxRowsAtCompileTime != Dynamic) ?
53                              int(MatrixType::MaxRowsAtCompileTime) - 1 : Dynamic,
54     MaxColsAtCompileTime = (MatrixType::MaxColsAtCompileTime != Dynamic) ?
55                              int(MatrixType::MaxColsAtCompileTime) - 1 : Dynamic,
56     Flags = _MatrixTypeNested::Flags & HereditaryBits,
57     CoeffReadCost = _MatrixTypeNested::CoeffReadCost
58   };
59 };
60
61 template<typename MatrixType> class Minor
62   : public MatrixBase<Minor<MatrixType> >
63 {
64   public:
65
66     EIGEN_GENERIC_PUBLIC_INTERFACE(Minor)
67
68     inline Minor(const MatrixType& matrix,
69                        int row, int col)
70       : m_matrix(matrix), m_row(row), m_col(col)
71     {
72       ei_assert(row >= 0 && row < matrix.rows()
73           && col >= 0 && col < matrix.cols());
74     }
75
76     EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Minor)
77
78     inline int rows() const { return m_matrix.rows() - 1; }
79     inline int cols() const { return m_matrix.cols() - 1; }
80
81     inline Scalar& coeffRef(int row, int col)
82     {
83       return m_matrix.const_cast_derived().coeffRef(row + (row >= m_row), col + (col >= m_col));
84     }
85
86     inline const Scalar coeff(int row, int col) const
87     {
88       return m_matrix.coeff(row + (row >= m_row), col + (col >= m_col));
89     }
90
91   protected:
92     const typename MatrixType::Nested m_matrix;
93     const int m_row, m_col;
94 };
95
96 /** \nonstableyet 
97   * \return an expression of the (\a row, \a col)-minor of *this,
98   * i.e. an expression constructed from *this by removing the specified
99   * row and column.
100   *
101   * Example: \include MatrixBase_minor.cpp
102   * Output: \verbinclude MatrixBase_minor.out
103   *
104   * \sa class Minor
105   */
106 template<typename Derived>
107 inline Minor<Derived>
108 MatrixBase<Derived>::minor(int row, int col)
109 {
110   return Minor<Derived>(derived(), row, col);
111 }
112
113 /** \nonstableyet 
114   * This is the const version of minor(). */
115 template<typename Derived>
116 inline const Minor<Derived>
117 MatrixBase<Derived>::minor(int row, int col) const
118 {
119   return Minor<Derived>(derived(), row, col);
120 }
121
122 #endif // EIGEN_MINOR_H