Merge of itasc branch. Project files, scons and cmake should be working. Makefile...
[blender.git] / extern / Eigen2 / Eigen / src / Core / Cwise.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 Gael Guennebaud <g.gael@free.fr>
5 // Copyright (C) 2008 Benoit Jacob <jacob.benoit.1@gmail.com>
6 //
7 // Eigen is free software; you can redistribute it and/or
8 // modify it under the terms of the GNU Lesser General Public
9 // License as published by the Free Software Foundation; either
10 // version 3 of the License, or (at your option) any later version.
11 //
12 // Alternatively, you can redistribute it and/or
13 // modify it under the terms of the GNU General Public License as
14 // published by the Free Software Foundation; either version 2 of
15 // the License, or (at your option) any later version.
16 //
17 // Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
18 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
19 // FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
20 // GNU General Public License for more details.
21 //
22 // You should have received a copy of the GNU Lesser General Public
23 // License and a copy of the GNU General Public License along with
24 // Eigen. If not, see <http://www.gnu.org/licenses/>.
25
26 #ifndef EIGEN_CWISE_H
27 #define EIGEN_CWISE_H
28
29 /** \internal
30   * convenient macro to defined the return type of a cwise binary operation */
31 #define EIGEN_CWISE_BINOP_RETURN_TYPE(OP) \
32     CwiseBinaryOp<OP<typename ei_traits<ExpressionType>::Scalar>, ExpressionType, OtherDerived>
33
34 #define EIGEN_CWISE_PRODUCT_RETURN_TYPE \
35     CwiseBinaryOp< \
36       ei_scalar_product_op< \
37         typename ei_scalar_product_traits< \
38           typename ei_traits<ExpressionType>::Scalar, \
39           typename ei_traits<OtherDerived>::Scalar \
40         >::ReturnType \
41       >, \
42       ExpressionType, \
43       OtherDerived \
44     >
45
46 /** \internal
47   * convenient macro to defined the return type of a cwise unary operation */
48 #define EIGEN_CWISE_UNOP_RETURN_TYPE(OP) \
49     CwiseUnaryOp<OP<typename ei_traits<ExpressionType>::Scalar>, ExpressionType>
50
51 /** \internal
52   * convenient macro to defined the return type of a cwise comparison to a scalar */
53 #define EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(OP) \
54     CwiseBinaryOp<OP<typename ei_traits<ExpressionType>::Scalar>, ExpressionType, \
55         NestByValue<typename ExpressionType::ConstantReturnType> >
56
57 /** \class Cwise
58   *
59   * \brief Pseudo expression providing additional coefficient-wise operations
60   *
61   * \param ExpressionType the type of the object on which to do coefficient-wise operations
62   *
63   * This class represents an expression with additional coefficient-wise features.
64   * It is the return type of MatrixBase::cwise()
65   * and most of the time this is the only way it is used.
66   *
67   * Note that some methods are defined in the \ref Array module.
68   *
69   * Example: \include MatrixBase_cwise_const.cpp
70   * Output: \verbinclude MatrixBase_cwise_const.out
71   *
72   * \sa MatrixBase::cwise() const, MatrixBase::cwise()
73   */
74 template<typename ExpressionType> class Cwise
75 {
76   public:
77
78     typedef typename ei_traits<ExpressionType>::Scalar Scalar;
79     typedef typename ei_meta_if<ei_must_nest_by_value<ExpressionType>::ret,
80         ExpressionType, const ExpressionType&>::ret ExpressionTypeNested;
81     typedef CwiseUnaryOp<ei_scalar_add_op<Scalar>, ExpressionType> ScalarAddReturnType;
82
83     inline Cwise(const ExpressionType& matrix) : m_matrix(matrix) {}
84
85     /** \internal */
86     inline const ExpressionType& _expression() const { return m_matrix; }
87
88     template<typename OtherDerived>
89     const EIGEN_CWISE_PRODUCT_RETURN_TYPE
90     operator*(const MatrixBase<OtherDerived> &other) const;
91
92     template<typename OtherDerived>
93     const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_quotient_op)
94     operator/(const MatrixBase<OtherDerived> &other) const;
95
96     template<typename OtherDerived>
97     const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_min_op)
98     min(const MatrixBase<OtherDerived> &other) const;
99
100     template<typename OtherDerived>
101     const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_max_op)
102     max(const MatrixBase<OtherDerived> &other) const;
103
104     const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_abs_op)      abs() const;
105     const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_abs2_op)     abs2() const;
106     const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_square_op)   square() const;
107     const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_cube_op)     cube() const;
108     const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_inverse_op)  inverse() const;
109     const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_sqrt_op)     sqrt() const;
110     const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_exp_op)      exp() const;
111     const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_log_op)      log() const;
112     const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_cos_op)      cos() const;
113     const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_sin_op)      sin() const;
114     const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_pow_op)      pow(const Scalar& exponent) const;
115
116     const ScalarAddReturnType
117     operator+(const Scalar& scalar) const;
118
119     /** \relates Cwise */
120     friend const ScalarAddReturnType
121     operator+(const Scalar& scalar, const Cwise& mat)
122     { return mat + scalar; }
123
124     ExpressionType& operator+=(const Scalar& scalar);
125
126     const ScalarAddReturnType
127     operator-(const Scalar& scalar) const;
128
129     ExpressionType& operator-=(const Scalar& scalar);
130
131     template<typename OtherDerived>
132     inline ExpressionType& operator*=(const MatrixBase<OtherDerived> &other);
133
134     template<typename OtherDerived>
135     inline ExpressionType& operator/=(const MatrixBase<OtherDerived> &other);
136
137     template<typename OtherDerived> const EIGEN_CWISE_BINOP_RETURN_TYPE(std::less)
138     operator<(const MatrixBase<OtherDerived>& other) const;
139
140     template<typename OtherDerived> const EIGEN_CWISE_BINOP_RETURN_TYPE(std::less_equal)
141     operator<=(const MatrixBase<OtherDerived>& other) const;
142
143     template<typename OtherDerived> const EIGEN_CWISE_BINOP_RETURN_TYPE(std::greater)
144     operator>(const MatrixBase<OtherDerived>& other) const;
145
146     template<typename OtherDerived> const EIGEN_CWISE_BINOP_RETURN_TYPE(std::greater_equal)
147     operator>=(const MatrixBase<OtherDerived>& other) const;
148
149     template<typename OtherDerived> const EIGEN_CWISE_BINOP_RETURN_TYPE(std::equal_to)
150     operator==(const MatrixBase<OtherDerived>& other) const;
151
152     template<typename OtherDerived> const EIGEN_CWISE_BINOP_RETURN_TYPE(std::not_equal_to)
153     operator!=(const MatrixBase<OtherDerived>& other) const;
154
155     // comparisons to a scalar value
156     const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::less)
157     operator<(Scalar s) const;
158
159     const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::less_equal)
160     operator<=(Scalar s) const;
161
162     const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::greater)
163     operator>(Scalar s) const;
164
165     const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::greater_equal)
166     operator>=(Scalar s) const;
167
168     const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::equal_to)
169     operator==(Scalar s) const;
170
171     const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::not_equal_to)
172     operator!=(Scalar s) const;
173
174     // allow to extend Cwise outside Eigen
175     #ifdef EIGEN_CWISE_PLUGIN
176     #include EIGEN_CWISE_PLUGIN
177     #endif
178
179   protected:
180     ExpressionTypeNested m_matrix;
181 };
182
183 /** \returns a Cwise wrapper of *this providing additional coefficient-wise operations
184   *
185   * Example: \include MatrixBase_cwise_const.cpp
186   * Output: \verbinclude MatrixBase_cwise_const.out
187   *
188   * \sa class Cwise, cwise()
189   */
190 template<typename Derived>
191 inline const Cwise<Derived>
192 MatrixBase<Derived>::cwise() const
193 {
194   return derived();
195 }
196
197 /** \returns a Cwise wrapper of *this providing additional coefficient-wise operations
198   *
199   * Example: \include MatrixBase_cwise.cpp
200   * Output: \verbinclude MatrixBase_cwise.out
201   *
202   * \sa class Cwise, cwise() const
203   */
204 template<typename Derived>
205 inline Cwise<Derived>
206 MatrixBase<Derived>::cwise()
207 {
208   return derived();
209 }
210
211 #endif // EIGEN_CWISE_H