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//
6// This Source Code Form is subject to the terms of the Mozilla
7// Public License v. 2.0. If a copy of the MPL was not distributed
8// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
9
10#ifndef EIGEN_VISITOR_H
11#define EIGEN_VISITOR_H
12
13namespace Eigen {
14
15namespace internal {
16
17template<typename Visitor, typename Derived, int UnrollCount>
18struct visitor_impl
19{
20 enum {
21 col = (UnrollCount-1) / Derived::RowsAtCompileTime,
22 row = (UnrollCount-1) % Derived::RowsAtCompileTime
23 };
24
25 EIGEN_DEVICE_FUNC
26 static inline void run(const Derived &mat, Visitor& visitor)
27 {
28 visitor_impl<Visitor, Derived, UnrollCount-1>::run(mat, visitor);
29 visitor(mat.coeff(row, col), row, col);
30 }
31};
32
33template<typename Visitor, typename Derived>
34struct visitor_impl<Visitor, Derived, 1>
35{
36 EIGEN_DEVICE_FUNC
37 static inline void run(const Derived &mat, Visitor& visitor)
38 {
39 return visitor.init(mat.coeff(0, 0), 0, 0);
40 }
41};
42
43// This specialization enables visitors on empty matrices at compile-time
44template<typename Visitor, typename Derived>
45struct visitor_impl<Visitor, Derived, 0> {
46 EIGEN_DEVICE_FUNC
47 static inline void run(const Derived &/*mat*/, Visitor& /*visitor*/)
48 {}
49};
50
51template<typename Visitor, typename Derived>
52struct visitor_impl<Visitor, Derived, Dynamic>
53{
54 EIGEN_DEVICE_FUNC
55 static inline void run(const Derived& mat, Visitor& visitor)
56 {
57 visitor.init(mat.coeff(0,0), 0, 0);
58 for(Index i = 1; i < mat.rows(); ++i)
59 visitor(mat.coeff(i, 0), i, 0);
60 for(Index j = 1; j < mat.cols(); ++j)
61 for(Index i = 0; i < mat.rows(); ++i)
62 visitor(mat.coeff(i, j), i, j);
63 }
64};
65
66// evaluator adaptor
67template<typename XprType>
68class visitor_evaluator
69{
70public:
71 EIGEN_DEVICE_FUNC
72 explicit visitor_evaluator(const XprType &xpr) : m_evaluator(xpr), m_xpr(xpr) {}
73
74 typedef typename XprType::Scalar Scalar;
75 typedef typename XprType::CoeffReturnType CoeffReturnType;
76
77 enum {
78 RowsAtCompileTime = XprType::RowsAtCompileTime,
79 CoeffReadCost = internal::evaluator<XprType>::CoeffReadCost
80 };
81
82 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_xpr.rows(); }
83 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_xpr.cols(); }
84 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index size() const EIGEN_NOEXCEPT { return m_xpr.size(); }
85
86 EIGEN_DEVICE_FUNC CoeffReturnType coeff(Index row, Index col) const
87 { return m_evaluator.coeff(row, col); }
88
89protected:
90 internal::evaluator<XprType> m_evaluator;
91 const XprType &m_xpr;
92};
93} // end namespace internal
94
95/** Applies the visitor \a visitor to the whole coefficients of the matrix or vector.
96 *
97 * The template parameter \a Visitor is the type of the visitor and provides the following interface:
98 * \code
99 * struct MyVisitor {
100 * // called for the first coefficient
101 * void init(const Scalar& value, Index i, Index j);
102 * // called for all other coefficients
103 * void operator() (const Scalar& value, Index i, Index j);
104 * };
105 * \endcode
106 *
107 * \note compared to one or two \em for \em loops, visitors offer automatic
108 * unrolling for small fixed size matrix.
109 *
110 * \note if the matrix is empty, then the visitor is left unchanged.
111 *
112 * \sa minCoeff(Index*,Index*), maxCoeff(Index*,Index*), DenseBase::redux()
113 */
114template<typename Derived>
115template<typename Visitor>
116EIGEN_DEVICE_FUNC
117void DenseBase<Derived>::visit(Visitor& visitor) const
118{
119 if(size()==0)
120 return;
121
122 typedef typename internal::visitor_evaluator<Derived> ThisEvaluator;
123 ThisEvaluator thisEval(derived());
124
125 enum {
126 unroll = SizeAtCompileTime != Dynamic
127 && SizeAtCompileTime * int(ThisEvaluator::CoeffReadCost) + (SizeAtCompileTime-1) * int(internal::functor_traits<Visitor>::Cost) <= EIGEN_UNROLLING_LIMIT
128 };
129 return internal::visitor_impl<Visitor, ThisEvaluator, unroll ? int(SizeAtCompileTime) : Dynamic>::run(thisEval, visitor);
130}
131
132namespace internal {
133
134/** \internal
135 * \brief Base class to implement min and max visitors
136 */
137template <typename Derived>
138struct coeff_visitor
139{
140 // default initialization to avoid countless invalid maybe-uninitialized warnings by gcc
141 EIGEN_DEVICE_FUNC
142 coeff_visitor() : row(-1), col(-1), res(0) {}
143 typedef typename Derived::Scalar Scalar;
144 Index row, col;
145 Scalar res;
146 EIGEN_DEVICE_FUNC
147 inline void init(const Scalar& value, Index i, Index j)
148 {
149 res = value;
150 row = i;
151 col = j;
152 }
153};
154
155/** \internal
156 * \brief Visitor computing the min coefficient with its value and coordinates
157 *
158 * \sa DenseBase::minCoeff(Index*, Index*)
159 */
160template <typename Derived, int NaNPropagation>
161struct min_coeff_visitor : coeff_visitor<Derived>
162{
163 typedef typename Derived::Scalar Scalar;
164 EIGEN_DEVICE_FUNC
165 void operator() (const Scalar& value, Index i, Index j)
166 {
167 if(value < this->res)
168 {
169 this->res = value;
170 this->row = i;
171 this->col = j;
172 }
173 }
174};
175
176template <typename Derived>
177struct min_coeff_visitor<Derived, PropagateNumbers> : coeff_visitor<Derived>
178{
179 typedef typename Derived::Scalar Scalar;
180 EIGEN_DEVICE_FUNC
181 void operator() (const Scalar& value, Index i, Index j)
182 {
183 if((numext::isnan)(this->res) || (!(numext::isnan)(value) && value < this->res))
184 {
185 this->res = value;
186 this->row = i;
187 this->col = j;
188 }
189 }
190};
191
192template <typename Derived>
193struct min_coeff_visitor<Derived, PropagateNaN> : coeff_visitor<Derived>
194{
195 typedef typename Derived::Scalar Scalar;
196 EIGEN_DEVICE_FUNC
197 void operator() (const Scalar& value, Index i, Index j)
198 {
199 if((numext::isnan)(value) || value < this->res)
200 {
201 this->res = value;
202 this->row = i;
203 this->col = j;
204 }
205 }
206};
207
208template<typename Scalar, int NaNPropagation>
209 struct functor_traits<min_coeff_visitor<Scalar, NaNPropagation> > {
210 enum {
211 Cost = NumTraits<Scalar>::AddCost
212 };
213};
214
215/** \internal
216 * \brief Visitor computing the max coefficient with its value and coordinates
217 *
218 * \sa DenseBase::maxCoeff(Index*, Index*)
219 */
220template <typename Derived, int NaNPropagation>
221struct max_coeff_visitor : coeff_visitor<Derived>
222{
223 typedef typename Derived::Scalar Scalar;
224 EIGEN_DEVICE_FUNC
225 void operator() (const Scalar& value, Index i, Index j)
226 {
227 if(value > this->res)
228 {
229 this->res = value;
230 this->row = i;
231 this->col = j;
232 }
233 }
234};
235
236template <typename Derived>
237struct max_coeff_visitor<Derived, PropagateNumbers> : coeff_visitor<Derived>
238{
239 typedef typename Derived::Scalar Scalar;
240 EIGEN_DEVICE_FUNC
241 void operator() (const Scalar& value, Index i, Index j)
242 {
243 if((numext::isnan)(this->res) || (!(numext::isnan)(value) && value > this->res))
244 {
245 this->res = value;
246 this->row = i;
247 this->col = j;
248 }
249 }
250};
251
252template <typename Derived>
253struct max_coeff_visitor<Derived, PropagateNaN> : coeff_visitor<Derived>
254{
255 typedef typename Derived::Scalar Scalar;
256 EIGEN_DEVICE_FUNC
257 void operator() (const Scalar& value, Index i, Index j)
258 {
259 if((numext::isnan)(value) || value > this->res)
260 {
261 this->res = value;
262 this->row = i;
263 this->col = j;
264 }
265 }
266};
267
268template<typename Scalar, int NaNPropagation>
269struct functor_traits<max_coeff_visitor<Scalar, NaNPropagation> > {
270 enum {
271 Cost = NumTraits<Scalar>::AddCost
272 };
273};
274
275} // end namespace internal
276
277/** \fn DenseBase<Derived>::minCoeff(IndexType* rowId, IndexType* colId) const
278 * \returns the minimum of all coefficients of *this and puts in *row and *col its location.
279 *
280 * In case \c *this contains NaN, NaNPropagation determines the behavior:
281 * NaNPropagation == PropagateFast : undefined
282 * NaNPropagation == PropagateNaN : result is NaN
283 * NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN
284 * \warning the matrix must be not empty, otherwise an assertion is triggered.
285 *
286 * \sa DenseBase::minCoeff(Index*), DenseBase::maxCoeff(Index*,Index*), DenseBase::visit(), DenseBase::minCoeff()
287 */
288template<typename Derived>
289template<int NaNPropagation, typename IndexType>
290EIGEN_DEVICE_FUNC
291typename internal::traits<Derived>::Scalar
292DenseBase<Derived>::minCoeff(IndexType* rowId, IndexType* colId) const
293{
294 eigen_assert(this->rows()>0 && this->cols()>0 && "you are using an empty matrix");
295
296 internal::min_coeff_visitor<Derived, NaNPropagation> minVisitor;
297 this->visit(minVisitor);
298 *rowId = minVisitor.row;
299 if (colId) *colId = minVisitor.col;
300 return minVisitor.res;
301}
302
303/** \returns the minimum of all coefficients of *this and puts in *index its location.
304 *
305 * In case \c *this contains NaN, NaNPropagation determines the behavior:
306 * NaNPropagation == PropagateFast : undefined
307 * NaNPropagation == PropagateNaN : result is NaN
308 * NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN
309 * \warning the matrix must be not empty, otherwise an assertion is triggered.
310 *
311 * \sa DenseBase::minCoeff(IndexType*,IndexType*), DenseBase::maxCoeff(IndexType*,IndexType*), DenseBase::visit(), DenseBase::minCoeff()
312 */
313template<typename Derived>
314template<int NaNPropagation, typename IndexType>
315EIGEN_DEVICE_FUNC
316typename internal::traits<Derived>::Scalar
317DenseBase<Derived>::minCoeff(IndexType* index) const
318{
319 eigen_assert(this->rows()>0 && this->cols()>0 && "you are using an empty matrix");
320
321 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
322 internal::min_coeff_visitor<Derived, NaNPropagation> minVisitor;
323 this->visit(minVisitor);
324 *index = IndexType((RowsAtCompileTime==1) ? minVisitor.col : minVisitor.row);
325 return minVisitor.res;
326}
327
328/** \fn DenseBase<Derived>::maxCoeff(IndexType* rowId, IndexType* colId) const
329 * \returns the maximum of all coefficients of *this and puts in *row and *col its location.
330 *
331 * In case \c *this contains NaN, NaNPropagation determines the behavior:
332 * NaNPropagation == PropagateFast : undefined
333 * NaNPropagation == PropagateNaN : result is NaN
334 * NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN
335 * \warning the matrix must be not empty, otherwise an assertion is triggered.
336 *
337 * \sa DenseBase::minCoeff(IndexType*,IndexType*), DenseBase::visit(), DenseBase::maxCoeff()
338 */
339template<typename Derived>
340template<int NaNPropagation, typename IndexType>
341EIGEN_DEVICE_FUNC
342typename internal::traits<Derived>::Scalar
343DenseBase<Derived>::maxCoeff(IndexType* rowPtr, IndexType* colPtr) const
344{
345 eigen_assert(this->rows()>0 && this->cols()>0 && "you are using an empty matrix");
346
347 internal::max_coeff_visitor<Derived, NaNPropagation> maxVisitor;
348 this->visit(maxVisitor);
349 *rowPtr = maxVisitor.row;
350 if (colPtr) *colPtr = maxVisitor.col;
351 return maxVisitor.res;
352}
353
354/** \returns the maximum of all coefficients of *this and puts in *index its location.
355 *
356 * In case \c *this contains NaN, NaNPropagation determines the behavior:
357 * NaNPropagation == PropagateFast : undefined
358 * NaNPropagation == PropagateNaN : result is NaN
359 * NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN
360 * \warning the matrix must be not empty, otherwise an assertion is triggered.
361 *
362 * \sa DenseBase::maxCoeff(IndexType*,IndexType*), DenseBase::minCoeff(IndexType*,IndexType*), DenseBase::visitor(), DenseBase::maxCoeff()
363 */
364template<typename Derived>
365template<int NaNPropagation, typename IndexType>
366EIGEN_DEVICE_FUNC
367typename internal::traits<Derived>::Scalar
368DenseBase<Derived>::maxCoeff(IndexType* index) const
369{
370 eigen_assert(this->rows()>0 && this->cols()>0 && "you are using an empty matrix");
371
372 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
373 internal::max_coeff_visitor<Derived, NaNPropagation> maxVisitor;
374 this->visit(maxVisitor);
375 *index = (RowsAtCompileTime==1) ? maxVisitor.col : maxVisitor.row;
376 return maxVisitor.res;
377}
378
379} // end namespace Eigen
380
381#endif // EIGEN_VISITOR_H
382

source code of qtmultimedia/src/3rdparty/eigen/Eigen/src/Core/Visitor.h