Merge of itasc branch. Project files, scons and cmake should be working. Makefile...
[blender.git] / extern / Eigen2 / Eigen / src / Array / CwiseOperators.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 //
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_ARRAY_CWISE_OPERATORS_H
26 #define EIGEN_ARRAY_CWISE_OPERATORS_H
27
28 // -- unary operators --
29
30 /** \array_module
31   * 
32   * \returns an expression of the coefficient-wise square root of *this.
33   *
34   * Example: \include Cwise_sqrt.cpp
35   * Output: \verbinclude Cwise_sqrt.out
36   *
37   * \sa pow(), square()
38   */
39 template<typename ExpressionType>
40 inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_sqrt_op)
41 Cwise<ExpressionType>::sqrt() const
42 {
43   return _expression();
44 }
45
46 /** \array_module
47   * 
48   * \returns an expression of the coefficient-wise exponential of *this.
49   *
50   * Example: \include Cwise_exp.cpp
51   * Output: \verbinclude Cwise_exp.out
52   *
53   * \sa pow(), log(), sin(), cos()
54   */
55 template<typename ExpressionType>
56 inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_exp_op)
57 Cwise<ExpressionType>::exp() const
58 {
59   return _expression();
60 }
61
62 /** \array_module
63   * 
64   * \returns an expression of the coefficient-wise logarithm of *this.
65   *
66   * Example: \include Cwise_log.cpp
67   * Output: \verbinclude Cwise_log.out
68   *
69   * \sa exp()
70   */
71 template<typename ExpressionType>
72 inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_log_op)
73 Cwise<ExpressionType>::log() const
74 {
75   return _expression();
76 }
77
78 /** \array_module
79   * 
80   * \returns an expression of the coefficient-wise cosine of *this.
81   *
82   * Example: \include Cwise_cos.cpp
83   * Output: \verbinclude Cwise_cos.out
84   *
85   * \sa sin(), exp()
86   */
87 template<typename ExpressionType>
88 inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_cos_op)
89 Cwise<ExpressionType>::cos() const
90 {
91   return _expression();
92 }
93
94
95 /** \array_module
96   * 
97   * \returns an expression of the coefficient-wise sine of *this.
98   *
99   * Example: \include Cwise_sin.cpp
100   * Output: \verbinclude Cwise_sin.out
101   *
102   * \sa cos(), exp()
103   */
104 template<typename ExpressionType>
105 inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_sin_op)
106 Cwise<ExpressionType>::sin() const
107 {
108   return _expression();
109 }
110
111
112 /** \array_module
113   * 
114   * \returns an expression of the coefficient-wise power of *this to the given exponent.
115   *
116   * Example: \include Cwise_pow.cpp
117   * Output: \verbinclude Cwise_pow.out
118   *
119   * \sa exp(), log()
120   */
121 template<typename ExpressionType>
122 inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_pow_op)
123 Cwise<ExpressionType>::pow(const Scalar& exponent) const
124 {
125   return EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_pow_op)(_expression(), ei_scalar_pow_op<Scalar>(exponent));
126 }
127
128
129 /** \array_module
130   * 
131   * \returns an expression of the coefficient-wise inverse of *this.
132   *
133   * Example: \include Cwise_inverse.cpp
134   * Output: \verbinclude Cwise_inverse.out
135   *
136   * \sa operator/(), operator*()
137   */
138 template<typename ExpressionType>
139 inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_inverse_op)
140 Cwise<ExpressionType>::inverse() const
141 {
142   return _expression();
143 }
144
145 /** \array_module
146   *
147   * \returns an expression of the coefficient-wise square of *this.
148   *
149   * Example: \include Cwise_square.cpp
150   * Output: \verbinclude Cwise_square.out
151   *
152   * \sa operator/(), operator*(), abs2()
153   */
154 template<typename ExpressionType>
155 inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_square_op)
156 Cwise<ExpressionType>::square() const
157 {
158   return _expression();
159 }
160
161 /** \array_module
162   *
163   * \returns an expression of the coefficient-wise cube of *this.
164   *
165   * Example: \include Cwise_cube.cpp
166   * Output: \verbinclude Cwise_cube.out
167   *
168   * \sa square(), pow()
169   */
170 template<typename ExpressionType>
171 inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_cube_op)
172 Cwise<ExpressionType>::cube() const
173 {
174   return _expression();
175 }
176
177
178 // -- binary operators --
179
180 /** \array_module
181   * 
182   * \returns an expression of the coefficient-wise \< operator of *this and \a other
183   *
184   * Example: \include Cwise_less.cpp
185   * Output: \verbinclude Cwise_less.out
186   *
187   * \sa MatrixBase::all(), MatrixBase::any(), operator>(), operator<=()
188   */
189 template<typename ExpressionType>
190 template<typename OtherDerived>
191 inline const EIGEN_CWISE_BINOP_RETURN_TYPE(std::less)
192 Cwise<ExpressionType>::operator<(const MatrixBase<OtherDerived> &other) const
193 {
194   return EIGEN_CWISE_BINOP_RETURN_TYPE(std::less)(_expression(), other.derived());
195 }
196
197 /** \array_module
198   * 
199   * \returns an expression of the coefficient-wise \<= operator of *this and \a other
200   *
201   * Example: \include Cwise_less_equal.cpp
202   * Output: \verbinclude Cwise_less_equal.out
203   *
204   * \sa MatrixBase::all(), MatrixBase::any(), operator>=(), operator<()
205   */
206 template<typename ExpressionType>
207 template<typename OtherDerived>
208 inline const EIGEN_CWISE_BINOP_RETURN_TYPE(std::less_equal)
209 Cwise<ExpressionType>::operator<=(const MatrixBase<OtherDerived> &other) const
210 {
211   return EIGEN_CWISE_BINOP_RETURN_TYPE(std::less_equal)(_expression(), other.derived());
212 }
213
214 /** \array_module
215   * 
216   * \returns an expression of the coefficient-wise \> operator of *this and \a other
217   *
218   * Example: \include Cwise_greater.cpp
219   * Output: \verbinclude Cwise_greater.out
220   *
221   * \sa MatrixBase::all(), MatrixBase::any(), operator>=(), operator<()
222   */
223 template<typename ExpressionType>
224 template<typename OtherDerived>
225 inline const EIGEN_CWISE_BINOP_RETURN_TYPE(std::greater)
226 Cwise<ExpressionType>::operator>(const MatrixBase<OtherDerived> &other) const
227 {
228   return EIGEN_CWISE_BINOP_RETURN_TYPE(std::greater)(_expression(), other.derived());
229 }
230
231 /** \array_module
232   * 
233   * \returns an expression of the coefficient-wise \>= operator of *this and \a other
234   *
235   * Example: \include Cwise_greater_equal.cpp
236   * Output: \verbinclude Cwise_greater_equal.out
237   *
238   * \sa MatrixBase::all(), MatrixBase::any(), operator>(), operator<=()
239   */
240 template<typename ExpressionType>
241 template<typename OtherDerived>
242 inline const EIGEN_CWISE_BINOP_RETURN_TYPE(std::greater_equal)
243 Cwise<ExpressionType>::operator>=(const MatrixBase<OtherDerived> &other) const
244 {
245   return EIGEN_CWISE_BINOP_RETURN_TYPE(std::greater_equal)(_expression(), other.derived());
246 }
247
248 /** \array_module
249   * 
250   * \returns an expression of the coefficient-wise == operator of *this and \a other
251   *
252   * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.
253   * In order to check for equality between two vectors or matrices with floating-point coefficients, it is
254   * generally a far better idea to use a fuzzy comparison as provided by MatrixBase::isApprox() and
255   * MatrixBase::isMuchSmallerThan().
256   *
257   * Example: \include Cwise_equal_equal.cpp
258   * Output: \verbinclude Cwise_equal_equal.out
259   *
260   * \sa MatrixBase::all(), MatrixBase::any(), MatrixBase::isApprox(), MatrixBase::isMuchSmallerThan()
261   */
262 template<typename ExpressionType>
263 template<typename OtherDerived>
264 inline const EIGEN_CWISE_BINOP_RETURN_TYPE(std::equal_to)
265 Cwise<ExpressionType>::operator==(const MatrixBase<OtherDerived> &other) const
266 {
267   return EIGEN_CWISE_BINOP_RETURN_TYPE(std::equal_to)(_expression(), other.derived());
268 }
269
270 /** \array_module
271   * 
272   * \returns an expression of the coefficient-wise != operator of *this and \a other
273   *
274   * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.
275   * In order to check for equality between two vectors or matrices with floating-point coefficients, it is
276   * generally a far better idea to use a fuzzy comparison as provided by MatrixBase::isApprox() and
277   * MatrixBase::isMuchSmallerThan().
278   *
279   * Example: \include Cwise_not_equal.cpp
280   * Output: \verbinclude Cwise_not_equal.out
281   *
282   * \sa MatrixBase::all(), MatrixBase::any(), MatrixBase::isApprox(), MatrixBase::isMuchSmallerThan()
283   */
284 template<typename ExpressionType>
285 template<typename OtherDerived>
286 inline const EIGEN_CWISE_BINOP_RETURN_TYPE(std::not_equal_to)
287 Cwise<ExpressionType>::operator!=(const MatrixBase<OtherDerived> &other) const
288 {
289   return EIGEN_CWISE_BINOP_RETURN_TYPE(std::not_equal_to)(_expression(), other.derived());
290 }
291
292 // comparisons to scalar value
293
294 /** \array_module
295   * 
296   * \returns an expression of the coefficient-wise \< operator of *this and a scalar \a s
297   *
298   * \sa operator<(const MatrixBase<OtherDerived> &) const
299   */
300 template<typename ExpressionType>
301 inline const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::less)
302 Cwise<ExpressionType>::operator<(Scalar s) const
303 {
304   return EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::less)(_expression(),
305             typename ExpressionType::ConstantReturnType(_expression().rows(), _expression().cols(), s));
306 }
307
308 /** \array_module
309   * 
310   * \returns an expression of the coefficient-wise \<= operator of *this and a scalar \a s
311   *
312   * \sa operator<=(const MatrixBase<OtherDerived> &) const
313   */
314 template<typename ExpressionType>
315 inline const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::less_equal)
316 Cwise<ExpressionType>::operator<=(Scalar s) const
317 {
318   return EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::less_equal)(_expression(),
319             typename ExpressionType::ConstantReturnType(_expression().rows(), _expression().cols(), s));
320 }
321
322 /** \array_module
323   * 
324   * \returns an expression of the coefficient-wise \> operator of *this and a scalar \a s
325   *
326   * \sa operator>(const MatrixBase<OtherDerived> &) const
327   */
328 template<typename ExpressionType>
329 inline const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::greater)
330 Cwise<ExpressionType>::operator>(Scalar s) const
331 {
332   return EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::greater)(_expression(),
333             typename ExpressionType::ConstantReturnType(_expression().rows(), _expression().cols(), s));
334 }
335
336 /** \array_module
337   * 
338   * \returns an expression of the coefficient-wise \>= operator of *this and a scalar \a s
339   *
340   * \sa operator>=(const MatrixBase<OtherDerived> &) const
341   */
342 template<typename ExpressionType>
343 inline const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::greater_equal)
344 Cwise<ExpressionType>::operator>=(Scalar s) const
345 {
346   return EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::greater_equal)(_expression(),
347             typename ExpressionType::ConstantReturnType(_expression().rows(), _expression().cols(), s));
348 }
349
350 /** \array_module
351   * 
352   * \returns an expression of the coefficient-wise == operator of *this and a scalar \a s
353   *
354   * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.
355   * In order to check for equality between two vectors or matrices with floating-point coefficients, it is
356   * generally a far better idea to use a fuzzy comparison as provided by MatrixBase::isApprox() and
357   * MatrixBase::isMuchSmallerThan().
358   *
359   * \sa operator==(const MatrixBase<OtherDerived> &) const
360   */
361 template<typename ExpressionType>
362 inline const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::equal_to)
363 Cwise<ExpressionType>::operator==(Scalar s) const
364 {
365   return EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::equal_to)(_expression(),
366             typename ExpressionType::ConstantReturnType(_expression().rows(), _expression().cols(), s));
367 }
368
369 /** \array_module
370   * 
371   * \returns an expression of the coefficient-wise != operator of *this and a scalar \a s
372   *
373   * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.
374   * In order to check for equality between two vectors or matrices with floating-point coefficients, it is
375   * generally a far better idea to use a fuzzy comparison as provided by MatrixBase::isApprox() and
376   * MatrixBase::isMuchSmallerThan().
377   *
378   * \sa operator!=(const MatrixBase<OtherDerived> &) const
379   */
380 template<typename ExpressionType>
381 inline const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::not_equal_to)
382 Cwise<ExpressionType>::operator!=(Scalar s) const
383 {
384   return EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::not_equal_to)(_expression(),
385             typename ExpressionType::ConstantReturnType(_expression().rows(), _expression().cols(), s));
386 }
387
388 // scalar addition
389
390 /** \array_module
391   *
392   * \returns an expression of \c *this with each coeff incremented by the constant \a scalar
393   *
394   * Example: \include Cwise_plus.cpp
395   * Output: \verbinclude Cwise_plus.out
396   *
397   * \sa operator+=(), operator-()
398   */
399 template<typename ExpressionType>
400 inline const typename Cwise<ExpressionType>::ScalarAddReturnType
401 Cwise<ExpressionType>::operator+(const Scalar& scalar) const
402 {
403   return typename Cwise<ExpressionType>::ScalarAddReturnType(m_matrix, ei_scalar_add_op<Scalar>(scalar));
404 }
405
406 /** \array_module
407   *
408   * Adds the given \a scalar to each coeff of this expression.
409   *
410   * Example: \include Cwise_plus_equal.cpp
411   * Output: \verbinclude Cwise_plus_equal.out
412   *
413   * \sa operator+(), operator-=()
414   */
415 template<typename ExpressionType>
416 inline ExpressionType& Cwise<ExpressionType>::operator+=(const Scalar& scalar)
417 {
418   return m_matrix.const_cast_derived() = *this + scalar;
419 }
420
421 /** \array_module
422   *
423   * \returns an expression of \c *this with each coeff decremented by the constant \a scalar
424   *
425   * Example: \include Cwise_minus.cpp
426   * Output: \verbinclude Cwise_minus.out
427   *
428   * \sa operator+(), operator-=()
429   */
430 template<typename ExpressionType>
431 inline const typename Cwise<ExpressionType>::ScalarAddReturnType
432 Cwise<ExpressionType>::operator-(const Scalar& scalar) const
433 {
434   return *this + (-scalar);
435 }
436
437 /** \array_module
438   *
439   * Substracts the given \a scalar from each coeff of this expression.
440   *
441   * Example: \include Cwise_minus_equal.cpp
442   * Output: \verbinclude Cwise_minus_equal.out
443   *
444   * \sa operator+=(), operator-()
445   */
446
447 template<typename ExpressionType>
448 inline ExpressionType& Cwise<ExpressionType>::operator-=(const Scalar& scalar)
449 {
450   return m_matrix.const_cast_derived() = *this - scalar;
451 }
452
453 #endif // EIGEN_ARRAY_CWISE_OPERATORS_H