Please, help us to better know about our user community by answering the following short survey: https://forms.gle/wpyrxWi18ox9Z5ae9
Eigen  3.4.0
 
Loading...
Searching...
No Matches
Visitor.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//
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
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
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
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
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
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
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
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
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
Base class for all dense matrices, vectors, and arrays.
Definition: DenseBase.h:47
@ PropagateNaN
Definition: Constants.h:343
@ PropagateNumbers
Definition: Constants.h:345
Namespace containing all symbols from the Eigen library.
Definition: Core:141
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74
const int Dynamic
Definition: Constants.h:22