Camera tracking integration
[blender.git] / extern / Eigen3 / Eigen / src / Eigen2Support / Cwise.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) 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 internal::traits<ExpressionType>::Scalar>, ExpressionType, OtherDerived>
33
34 /** \internal
35   * convenient macro to defined the return type of a cwise unary operation */
36 #define EIGEN_CWISE_UNOP_RETURN_TYPE(OP) \
37     CwiseUnaryOp<OP<typename internal::traits<ExpressionType>::Scalar>, ExpressionType>
38
39 /** \internal
40   * convenient macro to defined the return type of a cwise comparison to a scalar */
41 #define EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(OP) \
42     CwiseBinaryOp<OP<typename internal::traits<ExpressionType>::Scalar>, ExpressionType, \
43         typename ExpressionType::ConstantReturnType >
44
45 /** \class Cwise
46   *
47   * \brief Pseudo expression providing additional coefficient-wise operations
48   *
49   * \param ExpressionType the type of the object on which to do coefficient-wise operations
50   *
51   * This class represents an expression with additional coefficient-wise features.
52   * It is the return type of MatrixBase::cwise()
53   * and most of the time this is the only way it is used.
54   *
55   * Example: \include MatrixBase_cwise_const.cpp
56   * Output: \verbinclude MatrixBase_cwise_const.out
57   *
58   * This class can be extended with the help of the plugin mechanism described on the page
59   * \ref TopicCustomizingEigen by defining the preprocessor symbol \c EIGEN_CWISE_PLUGIN.
60   *
61   * \sa MatrixBase::cwise() const, MatrixBase::cwise()
62   */
63 template<typename ExpressionType> class Cwise
64 {
65   public:
66
67     typedef typename internal::traits<ExpressionType>::Scalar Scalar;
68     typedef typename internal::conditional<internal::must_nest_by_value<ExpressionType>::ret,
69         ExpressionType, const ExpressionType&>::type ExpressionTypeNested;
70     typedef CwiseUnaryOp<internal::scalar_add_op<Scalar>, ExpressionType> ScalarAddReturnType;
71
72     inline Cwise(const ExpressionType& matrix) : m_matrix(matrix) {}
73
74     /** \internal */
75     inline const ExpressionType& _expression() const { return m_matrix; }
76
77     template<typename OtherDerived>
78     const EIGEN_CWISE_PRODUCT_RETURN_TYPE(ExpressionType,OtherDerived)
79     operator*(const MatrixBase<OtherDerived> &other) const;
80
81     template<typename OtherDerived>
82     const EIGEN_CWISE_BINOP_RETURN_TYPE(internal::scalar_quotient_op)
83     operator/(const MatrixBase<OtherDerived> &other) const;
84
85     /** \deprecated ArrayBase::min() */
86     template<typename OtherDerived>
87     const EIGEN_CWISE_BINOP_RETURN_TYPE(internal::scalar_min_op)
88     (min)(const MatrixBase<OtherDerived> &other) const
89     { return EIGEN_CWISE_BINOP_RETURN_TYPE(internal::scalar_min_op)(_expression(), other.derived()); }
90
91     /** \deprecated ArrayBase::max() */
92     template<typename OtherDerived>
93     const EIGEN_CWISE_BINOP_RETURN_TYPE(internal::scalar_max_op)
94     (max)(const MatrixBase<OtherDerived> &other) const
95     { return EIGEN_CWISE_BINOP_RETURN_TYPE(internal::scalar_max_op)(_expression(), other.derived()); }
96
97     const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_abs_op)      abs() const;
98     const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_abs2_op)     abs2() const;
99     const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_square_op)   square() const;
100     const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_cube_op)     cube() const;
101     const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_inverse_op)  inverse() const;
102     const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_sqrt_op)     sqrt() const;
103     const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_exp_op)      exp() const;
104     const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_log_op)      log() const;
105     const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_cos_op)      cos() const;
106     const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_sin_op)      sin() const;
107     const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_pow_op)      pow(const Scalar& exponent) const;
108
109     const ScalarAddReturnType
110     operator+(const Scalar& scalar) const;
111
112     /** \relates Cwise */
113     friend const ScalarAddReturnType
114     operator+(const Scalar& scalar, const Cwise& mat)
115     { return mat + scalar; }
116
117     ExpressionType& operator+=(const Scalar& scalar);
118
119     const ScalarAddReturnType
120     operator-(const Scalar& scalar) const;
121
122     ExpressionType& operator-=(const Scalar& scalar);
123
124     template<typename OtherDerived>
125     inline ExpressionType& operator*=(const MatrixBase<OtherDerived> &other);
126
127     template<typename OtherDerived>
128     inline ExpressionType& operator/=(const MatrixBase<OtherDerived> &other);
129
130     template<typename OtherDerived> const EIGEN_CWISE_BINOP_RETURN_TYPE(std::less)
131     operator<(const MatrixBase<OtherDerived>& other) const;
132
133     template<typename OtherDerived> const EIGEN_CWISE_BINOP_RETURN_TYPE(std::less_equal)
134     operator<=(const MatrixBase<OtherDerived>& other) const;
135
136     template<typename OtherDerived> const EIGEN_CWISE_BINOP_RETURN_TYPE(std::greater)
137     operator>(const MatrixBase<OtherDerived>& other) const;
138
139     template<typename OtherDerived> const EIGEN_CWISE_BINOP_RETURN_TYPE(std::greater_equal)
140     operator>=(const MatrixBase<OtherDerived>& other) const;
141
142     template<typename OtherDerived> const EIGEN_CWISE_BINOP_RETURN_TYPE(std::equal_to)
143     operator==(const MatrixBase<OtherDerived>& other) const;
144
145     template<typename OtherDerived> const EIGEN_CWISE_BINOP_RETURN_TYPE(std::not_equal_to)
146     operator!=(const MatrixBase<OtherDerived>& other) const;
147
148     // comparisons to a scalar value
149     const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::less)
150     operator<(Scalar s) const;
151
152     const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::less_equal)
153     operator<=(Scalar s) const;
154
155     const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::greater)
156     operator>(Scalar s) const;
157
158     const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::greater_equal)
159     operator>=(Scalar s) const;
160
161     const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::equal_to)
162     operator==(Scalar s) const;
163
164     const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::not_equal_to)
165     operator!=(Scalar s) const;
166
167     // allow to extend Cwise outside Eigen
168     #ifdef EIGEN_CWISE_PLUGIN
169     #include EIGEN_CWISE_PLUGIN
170     #endif
171
172   protected:
173     ExpressionTypeNested m_matrix;
174 };
175
176
177 /** \returns a Cwise wrapper of *this providing additional coefficient-wise operations
178   *
179   * Example: \include MatrixBase_cwise_const.cpp
180   * Output: \verbinclude MatrixBase_cwise_const.out
181   *
182   * \sa class Cwise, cwise()
183   */
184 template<typename Derived>
185 inline const Cwise<Derived> MatrixBase<Derived>::cwise() const
186 {
187   return derived();
188 }
189
190 /** \returns a Cwise wrapper of *this providing additional coefficient-wise operations
191   *
192   * Example: \include MatrixBase_cwise.cpp
193   * Output: \verbinclude MatrixBase_cwise.out
194   *
195   * \sa class Cwise, cwise() const
196   */
197 template<typename Derived>
198 inline Cwise<Derived> MatrixBase<Derived>::cwise()
199 {
200   return derived();
201 }
202
203 #endif // EIGEN_CWISE_H