Merge of itasc branch. Project files, scons and cmake should be working. Makefile...
[blender.git] / extern / Eigen2 / Eigen / src / Core / Flagged.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) 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_FLAGGED_H
26 #define EIGEN_FLAGGED_H
27
28 /** \class Flagged
29   *
30   * \brief Expression with modified flags
31   *
32   * \param ExpressionType the type of the object of which we are modifying the flags
33   * \param Added the flags added to the expression
34   * \param Removed the flags removed from the expression (has priority over Added).
35   *
36   * This class represents an expression whose flags have been modified.
37   * It is the return type of MatrixBase::flagged()
38   * and most of the time this is the only way it is used.
39   *
40   * \sa MatrixBase::flagged()
41   */
42 template<typename ExpressionType, unsigned int Added, unsigned int Removed>
43 struct ei_traits<Flagged<ExpressionType, Added, Removed> > : ei_traits<ExpressionType>
44 {
45   enum { Flags = (ExpressionType::Flags | Added) & ~Removed };
46 };
47
48 template<typename ExpressionType, unsigned int Added, unsigned int Removed> class Flagged
49   : public MatrixBase<Flagged<ExpressionType, Added, Removed> >
50 {
51   public:
52
53     EIGEN_GENERIC_PUBLIC_INTERFACE(Flagged)
54     typedef typename ei_meta_if<ei_must_nest_by_value<ExpressionType>::ret,
55         ExpressionType, const ExpressionType&>::ret ExpressionTypeNested;
56     typedef typename ExpressionType::InnerIterator InnerIterator;
57
58     inline Flagged(const ExpressionType& matrix) : m_matrix(matrix) {}
59
60     inline int rows() const { return m_matrix.rows(); }
61     inline int cols() const { return m_matrix.cols(); }
62     inline int stride() const { return m_matrix.stride(); }
63
64     inline const Scalar coeff(int row, int col) const
65     {
66       return m_matrix.coeff(row, col);
67     }
68
69     inline Scalar& coeffRef(int row, int col)
70     {
71       return m_matrix.const_cast_derived().coeffRef(row, col);
72     }
73
74     inline const Scalar coeff(int index) const
75     {
76       return m_matrix.coeff(index);
77     }
78
79     inline Scalar& coeffRef(int index)
80     {
81       return m_matrix.const_cast_derived().coeffRef(index);
82     }
83
84     template<int LoadMode>
85     inline const PacketScalar packet(int row, int col) const
86     {
87       return m_matrix.template packet<LoadMode>(row, col);
88     }
89
90     template<int LoadMode>
91     inline void writePacket(int row, int col, const PacketScalar& x)
92     {
93       m_matrix.const_cast_derived().template writePacket<LoadMode>(row, col, x);
94     }
95
96     template<int LoadMode>
97     inline const PacketScalar packet(int index) const
98     {
99       return m_matrix.template packet<LoadMode>(index);
100     }
101
102     template<int LoadMode>
103     inline void writePacket(int index, const PacketScalar& x)
104     {
105       m_matrix.const_cast_derived().template writePacket<LoadMode>(index, x);
106     }
107
108     const ExpressionType& _expression() const { return m_matrix; }
109
110   protected:
111     ExpressionTypeNested m_matrix;
112 };
113
114 /** \returns an expression of *this with added flags
115   *
116   * \addexample MarkExample \label How to mark a triangular matrix as triangular
117   *
118   * Example: \include MatrixBase_marked.cpp
119   * Output: \verbinclude MatrixBase_marked.out
120   *
121   * \sa class Flagged, extract(), part()
122   */
123 template<typename Derived>
124 template<unsigned int Added>
125 inline const Flagged<Derived, Added, 0>
126 MatrixBase<Derived>::marked() const
127 {
128   return derived();
129 }
130
131 /** \returns an expression of *this with the following flags removed:
132   * EvalBeforeNestingBit and EvalBeforeAssigningBit.
133   *
134   * Example: \include MatrixBase_lazy.cpp
135   * Output: \verbinclude MatrixBase_lazy.out
136   *
137   * \sa class Flagged, marked()
138   */
139 template<typename Derived>
140 inline const Flagged<Derived, 0, EvalBeforeNestingBit | EvalBeforeAssigningBit>
141 MatrixBase<Derived>::lazy() const
142 {
143   return derived();
144 }
145
146 #endif // EIGEN_FLAGGED_H