mirror of
https://gitlab.com/libeigen/eigen.git
synced 2025-08-03 10:40:39 +08:00
843 lines
35 KiB
C++
843 lines
35 KiB
C++
// This file is part of Eigen, a lightweight C++ template library
|
|
// for linear algebra.
|
|
//
|
|
// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
|
|
//
|
|
// This Source Code Form is subject to the terms of the Mozilla
|
|
// Public License v. 2.0. If a copy of the MPL was not distributed
|
|
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
#ifndef EIGEN_VISITOR_H
|
|
#define EIGEN_VISITOR_H
|
|
|
|
// IWYU pragma: private
|
|
#include "./InternalHeaderCheck.h"
|
|
|
|
namespace Eigen {
|
|
|
|
namespace internal {
|
|
|
|
template <typename Visitor, typename Derived, int UnrollCount,
|
|
bool Vectorize = (Derived::PacketAccess && functor_traits<Visitor>::PacketAccess), bool LinearAccess = false,
|
|
bool ShortCircuitEvaluation = false>
|
|
struct visitor_impl;
|
|
|
|
template <typename Visitor, bool ShortCircuitEvaluation = false>
|
|
struct short_circuit_eval_impl {
|
|
// if short circuit evaluation is not used, do nothing
|
|
static EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool run(const Visitor&) { return false; }
|
|
};
|
|
template <typename Visitor>
|
|
struct short_circuit_eval_impl<Visitor, true> {
|
|
// if short circuit evaluation is used, check the visitor
|
|
static EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool run(const Visitor& visitor) {
|
|
return visitor.done();
|
|
}
|
|
};
|
|
|
|
// unrolled inner-outer traversal
|
|
template <typename Visitor, typename Derived, int UnrollCount, bool Vectorize, bool ShortCircuitEvaluation>
|
|
struct visitor_impl<Visitor, Derived, UnrollCount, Vectorize, false, ShortCircuitEvaluation> {
|
|
// don't use short circuit evaulation for unrolled version
|
|
using Scalar = typename Derived::Scalar;
|
|
using Packet = typename packet_traits<Scalar>::type;
|
|
static constexpr bool RowMajor = Derived::IsRowMajor;
|
|
static constexpr int RowsAtCompileTime = Derived::RowsAtCompileTime;
|
|
static constexpr int ColsAtCompileTime = Derived::ColsAtCompileTime;
|
|
static constexpr int PacketSize = packet_traits<Scalar>::size;
|
|
|
|
static constexpr bool CanVectorize(int K) {
|
|
constexpr int InnerSizeAtCompileTime = RowMajor ? ColsAtCompileTime : RowsAtCompileTime;
|
|
if(InnerSizeAtCompileTime < PacketSize) return false;
|
|
return Vectorize && (InnerSizeAtCompileTime - (K % InnerSizeAtCompileTime) >= PacketSize);
|
|
}
|
|
|
|
template <int K = 0,
|
|
bool Empty = (K == UnrollCount),
|
|
std::enable_if_t<Empty, bool> = true>
|
|
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived&, Visitor&) {}
|
|
|
|
template <int K = 0,
|
|
bool Empty = (K == UnrollCount),
|
|
bool Initialize = (K == 0),
|
|
bool DoVectorOp = CanVectorize(K),
|
|
std::enable_if_t<!Empty && Initialize && !DoVectorOp, bool> = true>
|
|
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived& mat, Visitor& visitor)
|
|
{
|
|
visitor.init(mat.coeff(0, 0), 0, 0);
|
|
run<1>(mat, visitor);
|
|
}
|
|
|
|
template <int K = 0,
|
|
bool Empty = (K == UnrollCount),
|
|
bool Initialize = (K == 0),
|
|
bool DoVectorOp = CanVectorize(K),
|
|
std::enable_if_t<!Empty && !Initialize && !DoVectorOp, bool> = true>
|
|
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived& mat, Visitor& visitor)
|
|
{
|
|
static constexpr int R = RowMajor ? (K / ColsAtCompileTime) : (K % RowsAtCompileTime);
|
|
static constexpr int C = RowMajor ? (K % ColsAtCompileTime) : (K / RowsAtCompileTime);
|
|
visitor(mat.coeff(R, C), R, C);
|
|
run<K + 1>(mat, visitor);
|
|
}
|
|
|
|
template <int K = 0,
|
|
bool Empty = (K == UnrollCount),
|
|
bool Initialize = (K == 0),
|
|
bool DoVectorOp = CanVectorize(K),
|
|
std::enable_if_t<!Empty && Initialize && DoVectorOp, bool> = true>
|
|
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived& mat, Visitor& visitor)
|
|
{
|
|
Packet P = mat.template packet<Packet>(0, 0);
|
|
visitor.initpacket(P, 0, 0);
|
|
run<PacketSize>(mat, visitor);
|
|
}
|
|
|
|
template <int K = 0,
|
|
bool Empty = (K == UnrollCount),
|
|
bool Initialize = (K == 0),
|
|
bool DoVectorOp = CanVectorize(K),
|
|
std::enable_if_t<!Empty && !Initialize && DoVectorOp, bool> = true>
|
|
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived& mat, Visitor& visitor)
|
|
{
|
|
static constexpr int R = RowMajor ? (K / ColsAtCompileTime) : (K % RowsAtCompileTime);
|
|
static constexpr int C = RowMajor ? (K % ColsAtCompileTime) : (K / RowsAtCompileTime);
|
|
Packet P = mat.template packet<Packet>(R, C);
|
|
visitor.packet(P, R, C);
|
|
run<K + PacketSize>(mat, visitor);
|
|
}
|
|
};
|
|
|
|
// unrolled linear traversal
|
|
template <typename Visitor, typename Derived, int UnrollCount, bool Vectorize, bool ShortCircuitEvaluation>
|
|
struct visitor_impl<Visitor, Derived, UnrollCount, Vectorize, true, ShortCircuitEvaluation> {
|
|
// don't use short circuit evaulation for unrolled version
|
|
using Scalar = typename Derived::Scalar;
|
|
using Packet = typename packet_traits<Scalar>::type;
|
|
static constexpr int PacketSize = packet_traits<Scalar>::size;
|
|
|
|
static constexpr bool CanVectorize(int K) {
|
|
return Vectorize && ((UnrollCount - K) >= PacketSize);
|
|
}
|
|
|
|
// empty
|
|
template <int K = 0,
|
|
bool Empty = (K == UnrollCount),
|
|
std::enable_if_t<Empty, bool> = true>
|
|
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived&, Visitor&) {}
|
|
|
|
// scalar initialization
|
|
template <int K = 0,
|
|
bool Empty = (K == UnrollCount),
|
|
bool Initialize = (K == 0),
|
|
bool DoVectorOp = CanVectorize(K),
|
|
std::enable_if_t<!Empty && Initialize && !DoVectorOp, bool> = true>
|
|
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived& mat, Visitor& visitor) {
|
|
visitor.init(mat.coeff(0), 0);
|
|
run<1>(mat, visitor);
|
|
}
|
|
|
|
// scalar iteration
|
|
template <int K = 0,
|
|
bool Empty = (K == UnrollCount),
|
|
bool Initialize = (K == 0),
|
|
bool DoVectorOp = CanVectorize(K),
|
|
std::enable_if_t<!Empty && !Initialize && !DoVectorOp, bool> = true>
|
|
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived& mat, Visitor& visitor) {
|
|
visitor(mat.coeff(K), K);
|
|
run<K + 1>(mat, visitor);
|
|
}
|
|
|
|
// vector initialization
|
|
template <int K = 0,
|
|
bool Empty = (K == UnrollCount),
|
|
bool Initialize = (K == 0),
|
|
bool DoVectorOp = CanVectorize(K),
|
|
std::enable_if_t<!Empty && Initialize && DoVectorOp, bool> = true>
|
|
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived& mat, Visitor& visitor) {
|
|
Packet P = mat.template packet<Packet>(0);
|
|
visitor.initpacket(P, 0);
|
|
run<PacketSize>(mat, visitor);
|
|
}
|
|
|
|
// vector iteration
|
|
template <int K = 0,
|
|
bool Empty = (K == UnrollCount),
|
|
bool Initialize = (K == 0),
|
|
bool DoVectorOp = CanVectorize(K),
|
|
std::enable_if_t<!Empty && !Initialize && DoVectorOp, bool> = true>
|
|
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived& mat, Visitor& visitor) {
|
|
Packet P = mat.template packet<Packet>(K);
|
|
visitor.packet(P, K);
|
|
run<K + PacketSize>(mat, visitor);
|
|
}
|
|
};
|
|
|
|
// dynamic scalar outer-inner traversal
|
|
template <typename Visitor, typename Derived, bool ShortCircuitEvaluation>
|
|
struct visitor_impl<Visitor, Derived, Dynamic, /*Vectorize=*/false, /*LinearAccess=*/false, ShortCircuitEvaluation> {
|
|
using short_circuit = short_circuit_eval_impl<Visitor, ShortCircuitEvaluation>;
|
|
static constexpr bool RowMajor = Derived::IsRowMajor;
|
|
|
|
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived& mat, Visitor& visitor) {
|
|
const Index innerSize = RowMajor ? mat.cols() : mat.rows();
|
|
const Index outerSize = RowMajor ? mat.rows() : mat.cols();
|
|
if (innerSize == 0 || outerSize == 0) return;
|
|
{
|
|
visitor.init(mat.coeff(0, 0), 0, 0);
|
|
if (short_circuit::run(visitor)) return;
|
|
for (Index i = 1; i < innerSize; ++i) {
|
|
Index r = RowMajor ? 0 : i;
|
|
Index c = RowMajor ? i : 0;
|
|
visitor(mat.coeff(r, c), r, c);
|
|
if EIGEN_PREDICT_FALSE(short_circuit::run(visitor)) return;
|
|
}
|
|
}
|
|
for (Index j = 1; j < outerSize; j++) {
|
|
for (Index i = 0; i < innerSize; ++i) {
|
|
Index r = RowMajor ? j : i;
|
|
Index c = RowMajor ? i : j;
|
|
visitor(mat.coeff(r, c), r, c);
|
|
if EIGEN_PREDICT_FALSE(short_circuit::run(visitor)) return;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// dynamic vectorized outer-inner traversal
|
|
template <typename Visitor, typename Derived, bool ShortCircuitEvaluation>
|
|
struct visitor_impl<Visitor, Derived, Dynamic, /*Vectorize=*/true, /*LinearAccess=*/false, ShortCircuitEvaluation> {
|
|
using Scalar = typename Derived::Scalar;
|
|
using Packet = typename packet_traits<Scalar>::type;
|
|
static constexpr int PacketSize = packet_traits<Scalar>::size;
|
|
using short_circuit = short_circuit_eval_impl<Visitor, ShortCircuitEvaluation>;
|
|
static constexpr bool RowMajor = Derived::IsRowMajor;
|
|
|
|
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived& mat, Visitor& visitor) {
|
|
const Index innerSize = RowMajor ? mat.cols() : mat.rows();
|
|
const Index outerSize = RowMajor ? mat.rows() : mat.cols();
|
|
if (innerSize == 0 || outerSize == 0) return;
|
|
{
|
|
Index i = 0;
|
|
if (innerSize < PacketSize) {
|
|
visitor.init(mat.coeff(0, 0), 0, 0);
|
|
i = 1;
|
|
} else {
|
|
Packet p = mat.template packet<Packet>(0, 0);
|
|
visitor.initpacket(p, 0, 0);
|
|
i = PacketSize;
|
|
}
|
|
if EIGEN_PREDICT_FALSE(short_circuit::run(visitor)) return;
|
|
for (; i + PacketSize - 1 < innerSize; i += PacketSize) {
|
|
Index r = RowMajor ? 0 : i;
|
|
Index c = RowMajor ? i : 0;
|
|
Packet p = mat.template packet<Packet>(r, c);
|
|
visitor.packet(p, r, c);
|
|
if EIGEN_PREDICT_FALSE(short_circuit::run(visitor)) return;
|
|
}
|
|
for (; i < innerSize; ++i) {
|
|
Index r = RowMajor ? 0 : i;
|
|
Index c = RowMajor ? i : 0;
|
|
visitor(mat.coeff(r, c), r, c);
|
|
if EIGEN_PREDICT_FALSE(short_circuit::run(visitor)) return;
|
|
}
|
|
}
|
|
for (Index j = 1; j < outerSize; j++) {
|
|
Index i = 0;
|
|
for (; i + PacketSize - 1 < innerSize; i += PacketSize) {
|
|
Index r = RowMajor ? j : i;
|
|
Index c = RowMajor ? i : j;
|
|
Packet p = mat.template packet<Packet>(r, c);
|
|
visitor.packet(p, r, c);
|
|
if EIGEN_PREDICT_FALSE(short_circuit::run(visitor)) return;
|
|
}
|
|
for (; i < innerSize; ++i) {
|
|
Index r = RowMajor ? j : i;
|
|
Index c = RowMajor ? i : j;
|
|
visitor(mat.coeff(r, c), r, c);
|
|
if EIGEN_PREDICT_FALSE(short_circuit::run(visitor)) return;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// dynamic scalar linear traversal
|
|
template <typename Visitor, typename Derived, bool ShortCircuitEvaluation>
|
|
struct visitor_impl<Visitor, Derived, Dynamic, /*Vectorize=*/false, /*LinearAccess=*/true, ShortCircuitEvaluation> {
|
|
using short_circuit = short_circuit_eval_impl<Visitor, ShortCircuitEvaluation>;
|
|
|
|
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived& mat, Visitor& visitor) {
|
|
const Index size = mat.size();
|
|
if (size == 0) return;
|
|
visitor.init(mat.coeff(0), 0);
|
|
if EIGEN_PREDICT_FALSE(short_circuit::run(visitor)) return;
|
|
for (Index k = 1; k < size; k++) {
|
|
visitor(mat.coeff(k), k);
|
|
if EIGEN_PREDICT_FALSE(short_circuit::run(visitor)) return;
|
|
}
|
|
}
|
|
};
|
|
|
|
// dynamic vectorized linear traversal
|
|
template <typename Visitor, typename Derived, bool ShortCircuitEvaluation>
|
|
struct visitor_impl<Visitor, Derived, Dynamic, /*Vectorize=*/true, /*LinearAccess=*/true, ShortCircuitEvaluation> {
|
|
using Scalar = typename Derived::Scalar;
|
|
using Packet = typename packet_traits<Scalar>::type;
|
|
static constexpr int PacketSize = packet_traits<Scalar>::size;
|
|
using short_circuit = short_circuit_eval_impl<Visitor, ShortCircuitEvaluation>;
|
|
|
|
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived& mat, Visitor& visitor) {
|
|
const Index size = mat.size();
|
|
if (size == 0) return;
|
|
Index k = 0;
|
|
if (size < PacketSize) {
|
|
visitor.init(mat.coeff(0), 0);
|
|
k = 1;
|
|
} else {
|
|
Packet p = mat.template packet<Packet>(k);
|
|
visitor.initpacket(p, k);
|
|
k = PacketSize;
|
|
}
|
|
if EIGEN_PREDICT_FALSE(short_circuit::run(visitor)) return;
|
|
for (; k + PacketSize - 1 < size; k += PacketSize) {
|
|
Packet p = mat.template packet<Packet>(k);
|
|
visitor.packet(p, k);
|
|
if EIGEN_PREDICT_FALSE(short_circuit::run(visitor)) return;
|
|
}
|
|
for (; k < size; k++) {
|
|
visitor(mat.coeff(k), k);
|
|
if EIGEN_PREDICT_FALSE(short_circuit::run(visitor)) return;
|
|
}
|
|
}
|
|
};
|
|
|
|
// evaluator adaptor
|
|
template<typename XprType>
|
|
class visitor_evaluator
|
|
{
|
|
public:
|
|
typedef evaluator<XprType> Evaluator;
|
|
typedef typename XprType::Scalar Scalar;
|
|
using Packet = typename packet_traits<Scalar>::type;
|
|
typedef std::remove_const_t<typename XprType::CoeffReturnType> CoeffReturnType;
|
|
|
|
static constexpr bool PacketAccess = static_cast<bool>(Evaluator::Flags & PacketAccessBit);
|
|
static constexpr bool LinearAccess = static_cast<bool>(Evaluator::Flags & LinearAccessBit);
|
|
static constexpr bool IsRowMajor = static_cast<bool>(XprType::IsRowMajor);
|
|
static constexpr int RowsAtCompileTime = XprType::RowsAtCompileTime;
|
|
static constexpr int ColsAtCompileTime = XprType::ColsAtCompileTime;
|
|
static constexpr int XprAlignment = Evaluator::Alignment;
|
|
static constexpr int CoeffReadCost = Evaluator::CoeffReadCost;
|
|
|
|
EIGEN_DEVICE_FUNC
|
|
explicit visitor_evaluator(const XprType &xpr) : m_evaluator(xpr), m_xpr(xpr) { }
|
|
|
|
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_xpr.rows(); }
|
|
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_xpr.cols(); }
|
|
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index size() const EIGEN_NOEXCEPT { return m_xpr.size(); }
|
|
// outer-inner access
|
|
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const { return m_evaluator.coeff(row, col); }
|
|
template <typename Packet, int Alignment = Unaligned>
|
|
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packet(Index row, Index col) const {
|
|
return m_evaluator.template packet<Alignment, Packet>(row, col);
|
|
}
|
|
// linear access
|
|
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { return m_evaluator.coeff(index); }
|
|
template <typename Packet, int Alignment = XprAlignment>
|
|
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packet(Index index) const {
|
|
return m_evaluator.template packet<Alignment, Packet>(index);
|
|
}
|
|
|
|
protected:
|
|
Evaluator m_evaluator;
|
|
const XprType &m_xpr;
|
|
};
|
|
|
|
template <typename Derived, typename Visitor, bool ShortCircuitEvaulation>
|
|
struct visit_impl {
|
|
using Evaluator = visitor_evaluator<Derived>;
|
|
using Scalar = typename DenseBase<Derived>::Scalar;
|
|
|
|
static constexpr bool IsRowMajor = DenseBase<Derived>::IsRowMajor;
|
|
static constexpr int SizeAtCompileTime = DenseBase<Derived>::SizeAtCompileTime;
|
|
static constexpr int RowsAtCompileTime = DenseBase<Derived>::RowsAtCompileTime;
|
|
static constexpr int ColsAtCompileTime = DenseBase<Derived>::ColsAtCompileTime;
|
|
static constexpr int InnerSizeAtCompileTime = IsRowMajor ? ColsAtCompileTime : RowsAtCompileTime;
|
|
static constexpr int OuterSizeAtCompileTime = IsRowMajor ? RowsAtCompileTime : ColsAtCompileTime;
|
|
|
|
static constexpr bool LinearAccess = Evaluator::LinearAccess && static_cast<bool>(functor_traits<Visitor>::LinearAccess);
|
|
static constexpr bool Vectorize = Evaluator::PacketAccess && static_cast<bool>(functor_traits<Visitor>::PacketAccess);
|
|
|
|
static constexpr int PacketSize = packet_traits<Scalar>::size;
|
|
static constexpr int VectorOps = Vectorize ? (LinearAccess ? (SizeAtCompileTime / PacketSize) : (OuterSizeAtCompileTime * (InnerSizeAtCompileTime / PacketSize))) : 0;
|
|
static constexpr int ScalarOps = SizeAtCompileTime - (VectorOps * PacketSize);
|
|
// treat vector op and scalar op as same cost for unroll logic
|
|
static constexpr int TotalOps = VectorOps + ScalarOps;
|
|
|
|
static constexpr int UnrollCost = int(Evaluator::CoeffReadCost) + int(functor_traits<Visitor>::Cost);
|
|
static constexpr bool Unroll = (SizeAtCompileTime != Dynamic) && ((TotalOps * UnrollCost) <= EIGEN_UNROLLING_LIMIT);
|
|
static constexpr int UnrollCount = Unroll ? int(SizeAtCompileTime) : Dynamic;
|
|
|
|
|
|
using impl = visitor_impl<Visitor, Evaluator, UnrollCount, Vectorize, LinearAccess, ShortCircuitEvaulation>;
|
|
|
|
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const DenseBase<Derived>& mat, Visitor& visitor) {
|
|
Evaluator evaluator(mat.derived());
|
|
impl::run(evaluator, visitor);
|
|
}
|
|
};
|
|
|
|
} // end namespace internal
|
|
|
|
/** Applies the visitor \a visitor to the whole coefficients of the matrix or vector.
|
|
*
|
|
* The template parameter \a Visitor is the type of the visitor and provides the following interface:
|
|
* \code
|
|
* struct MyVisitor {
|
|
* // called for the first coefficient
|
|
* void init(const Scalar& value, Index i, Index j);
|
|
* // called for all other coefficients
|
|
* void operator() (const Scalar& value, Index i, Index j);
|
|
* };
|
|
* \endcode
|
|
*
|
|
* \note compared to one or two \em for \em loops, visitors offer automatic
|
|
* unrolling for small fixed size matrix.
|
|
*
|
|
* \note if the matrix is empty, then the visitor is left unchanged.
|
|
*
|
|
* \sa minCoeff(Index*,Index*), maxCoeff(Index*,Index*), DenseBase::redux()
|
|
*/
|
|
template<typename Derived>
|
|
template<typename Visitor>
|
|
EIGEN_DEVICE_FUNC
|
|
void DenseBase<Derived>::visit(Visitor& visitor) const
|
|
{
|
|
using impl = internal::visit_impl<Derived, Visitor, /*ShortCircuitEvaulation*/false>;
|
|
impl::run(derived(), visitor);
|
|
}
|
|
|
|
namespace internal {
|
|
|
|
/** \internal
|
|
* \brief Base class to implement min and max visitors
|
|
*/
|
|
template <typename Derived>
|
|
struct coeff_visitor
|
|
{
|
|
// default initialization to avoid countless invalid maybe-uninitialized warnings by gcc
|
|
EIGEN_DEVICE_FUNC
|
|
coeff_visitor() : row(-1), col(-1), res(0) {}
|
|
typedef typename Derived::Scalar Scalar;
|
|
Index row, col;
|
|
Scalar res;
|
|
EIGEN_DEVICE_FUNC
|
|
inline void init(const Scalar& value, Index i, Index j)
|
|
{
|
|
res = value;
|
|
row = i;
|
|
col = j;
|
|
}
|
|
};
|
|
|
|
|
|
template <typename Scalar, int NaNPropagation, bool is_min = true>
|
|
struct minmax_compare {
|
|
typedef typename packet_traits<Scalar>::type Packet;
|
|
static EIGEN_DEVICE_FUNC inline bool compare(Scalar a, Scalar b) { return a < b; }
|
|
static EIGEN_DEVICE_FUNC inline Scalar predux(const Packet& p) { return predux_min<NaNPropagation>(p); }
|
|
};
|
|
|
|
template <typename Scalar, int NaNPropagation>
|
|
struct minmax_compare<Scalar, NaNPropagation, false> {
|
|
typedef typename packet_traits<Scalar>::type Packet;
|
|
static EIGEN_DEVICE_FUNC inline bool compare(Scalar a, Scalar b) { return a > b; }
|
|
static EIGEN_DEVICE_FUNC inline Scalar predux(const Packet& p) { return predux_max<NaNPropagation>(p); }
|
|
};
|
|
|
|
// Default implementation used by non-floating types, where we do not
|
|
// need special logic for NaN handling.
|
|
template <typename Derived, bool is_min, int NaNPropagation,
|
|
bool isInt = NumTraits<typename Derived::Scalar>::IsInteger>
|
|
struct minmax_coeff_visitor : coeff_visitor<Derived> {
|
|
using Scalar = typename Derived::Scalar;
|
|
using Packet = typename packet_traits<Scalar>::type;
|
|
using Comparator = minmax_compare<Scalar, NaNPropagation, is_min>;
|
|
static constexpr Index PacketSize = packet_traits<Scalar>::size;
|
|
|
|
EIGEN_DEVICE_FUNC inline void operator()(const Scalar& value, Index i, Index j) {
|
|
if (Comparator::compare(value, this->res)) {
|
|
this->res = value;
|
|
this->row = i;
|
|
this->col = j;
|
|
}
|
|
}
|
|
EIGEN_DEVICE_FUNC inline void packet(const Packet& p, Index i, Index j) {
|
|
Scalar value = Comparator::predux(p);
|
|
if (Comparator::compare(value, this->res)) {
|
|
const Packet range = preverse(plset<Packet>(Scalar(1)));
|
|
Packet mask = pcmp_eq(pset1<Packet>(value), p);
|
|
Index max_idx = PacketSize - static_cast<Index>(predux_max(pand(range, mask)));
|
|
this->res = value;
|
|
this->row = Derived::IsRowMajor ? i : i + max_idx;
|
|
this->col = Derived::IsRowMajor ? j + max_idx : j;
|
|
}
|
|
}
|
|
EIGEN_DEVICE_FUNC inline void initpacket(const Packet& p, Index i, Index j) {
|
|
Scalar value = Comparator::predux(p);
|
|
const Packet range = preverse(plset<Packet>(Scalar(1)));
|
|
Packet mask = pcmp_eq(pset1<Packet>(value), p);
|
|
Index max_idx = PacketSize - static_cast<Index>(predux_max(pand(range, mask)));
|
|
this->res = value;
|
|
this->row = Derived::IsRowMajor ? i : i + max_idx;
|
|
this->col = Derived::IsRowMajor ? j + max_idx : j;
|
|
}
|
|
};
|
|
|
|
// Suppress NaN. The only case in which we return NaN is if the matrix is all NaN,
|
|
// in which case, row=0, col=0 is returned for the location.
|
|
template <typename Derived, bool is_min>
|
|
struct minmax_coeff_visitor<Derived, is_min, PropagateNumbers, false> : coeff_visitor<Derived> {
|
|
typedef typename Derived::Scalar Scalar;
|
|
using Packet = typename packet_traits<Scalar>::type;
|
|
using Comparator = minmax_compare<Scalar, PropagateNumbers, is_min>;
|
|
|
|
EIGEN_DEVICE_FUNC inline void operator()(const Scalar& value, Index i, Index j) {
|
|
if ((!(numext::isnan)(value) && (numext::isnan)(this->res)) || Comparator::compare(value, this->res)) {
|
|
this->res = value;
|
|
this->row = i;
|
|
this->col = j;
|
|
}
|
|
}
|
|
EIGEN_DEVICE_FUNC inline void packet(const Packet& p, Index i, Index j) {
|
|
const Index PacketSize = packet_traits<Scalar>::size;
|
|
Scalar value = Comparator::predux(p);
|
|
if ((!(numext::isnan)(value) && (numext::isnan)(this->res)) || Comparator::compare(value, this->res)) {
|
|
const Packet range = preverse(plset<Packet>(Scalar(1)));
|
|
/* mask will be zero for NaNs, so they will be ignored. */
|
|
Packet mask = pcmp_eq(pset1<Packet>(value), p);
|
|
Index max_idx = PacketSize - static_cast<Index>(predux_max(pand(range, mask)));
|
|
this->res = value;
|
|
this->row = Derived::IsRowMajor ? i : i + max_idx;
|
|
this->col = Derived::IsRowMajor ? j + max_idx : j;
|
|
}
|
|
}
|
|
EIGEN_DEVICE_FUNC inline void initpacket(const Packet& p, Index i, Index j) {
|
|
const Index PacketSize = packet_traits<Scalar>::size;
|
|
Scalar value = Comparator::predux(p);
|
|
if ((numext::isnan)(value)) {
|
|
this->res = value;
|
|
this->row = 0;
|
|
this->col = 0;
|
|
return;
|
|
}
|
|
const Packet range = preverse(plset<Packet>(Scalar(1)));
|
|
/* mask will be zero for NaNs, so they will be ignored. */
|
|
Packet mask = pcmp_eq(pset1<Packet>(value), p);
|
|
Index max_idx = PacketSize - static_cast<Index>(predux_max(pand(range, mask)));
|
|
this->res = value;
|
|
this->row = Derived::IsRowMajor ? i : i + max_idx;
|
|
this->col = Derived::IsRowMajor ? j + max_idx : j;
|
|
}
|
|
};
|
|
|
|
// Propagate NaNs. If the matrix contains NaN, the location of the first NaN
|
|
// will be returned in row and col.
|
|
template <typename Derived, bool is_min, int NaNPropagation>
|
|
struct minmax_coeff_visitor<Derived, is_min, NaNPropagation, false> : coeff_visitor<Derived> {
|
|
typedef typename Derived::Scalar Scalar;
|
|
using Packet = typename packet_traits<Scalar>::type;
|
|
using Comparator = minmax_compare<Scalar, PropagateNaN, is_min>;
|
|
|
|
EIGEN_DEVICE_FUNC inline void operator()(const Scalar& value, Index i, Index j) {
|
|
const bool value_is_nan = (numext::isnan)(value);
|
|
if ((value_is_nan && !(numext::isnan)(this->res)) || Comparator::compare(value, this->res)) {
|
|
this->res = value;
|
|
this->row = i;
|
|
this->col = j;
|
|
}
|
|
}
|
|
EIGEN_DEVICE_FUNC inline void packet(const Packet& p, Index i, Index j) {
|
|
const Index PacketSize = packet_traits<Scalar>::size;
|
|
Scalar value = Comparator::predux(p);
|
|
const bool value_is_nan = (numext::isnan)(value);
|
|
if ((value_is_nan && !(numext::isnan)(this->res)) || Comparator::compare(value, this->res)) {
|
|
const Packet range = preverse(plset<Packet>(Scalar(1)));
|
|
// If the value is NaN, pick the first position of a NaN, otherwise pick the first extremal value.
|
|
Packet mask = value_is_nan ? pnot(pcmp_eq(p, p)) : pcmp_eq(pset1<Packet>(value), p);
|
|
Index max_idx = PacketSize - static_cast<Index>(predux_max(pand(range, mask)));
|
|
this->res = value;
|
|
this->row = Derived::IsRowMajor ? i : i + max_idx;
|
|
this->col = Derived::IsRowMajor ? j + max_idx : j;
|
|
}
|
|
}
|
|
EIGEN_DEVICE_FUNC inline void initpacket(const Packet& p, Index i, Index j) {
|
|
const Index PacketSize = packet_traits<Scalar>::size;
|
|
Scalar value = Comparator::predux(p);
|
|
const bool value_is_nan = (numext::isnan)(value);
|
|
const Packet range = preverse(plset<Packet>(Scalar(1)));
|
|
// If the value is NaN, pick the first position of a NaN, otherwise pick the first extremal value.
|
|
Packet mask = value_is_nan ? pnot(pcmp_eq(p, p)) : pcmp_eq(pset1<Packet>(value), p);
|
|
Index max_idx = PacketSize - static_cast<Index>(predux_max(pand(range, mask)));
|
|
this->res = value;
|
|
this->row = Derived::IsRowMajor ? i : i + max_idx;
|
|
this->col = Derived::IsRowMajor ? j + max_idx : j;
|
|
}
|
|
};
|
|
|
|
template<typename Derived, bool is_min, int NaNPropagation>
|
|
struct functor_traits<minmax_coeff_visitor<Derived, is_min, NaNPropagation> > {
|
|
using Scalar = typename Derived::Scalar;
|
|
enum {
|
|
Cost = NumTraits<Scalar>::AddCost,
|
|
LinearAccess = false,
|
|
PacketAccess = packet_traits<Scalar>::HasCmp
|
|
};
|
|
};
|
|
|
|
template <typename Scalar>
|
|
struct all_visitor {
|
|
using result_type = bool;
|
|
using Packet = typename packet_traits<Scalar>::type;
|
|
EIGEN_DEVICE_FUNC inline void init(const Scalar& value, Index, Index) { res = (value != Scalar(0)); }
|
|
EIGEN_DEVICE_FUNC inline void init(const Scalar& value, Index) { res = (value != Scalar(0)); }
|
|
EIGEN_DEVICE_FUNC inline bool all_predux(const Packet& p) const { return !predux_any(pcmp_eq(p, pzero(p))); }
|
|
EIGEN_DEVICE_FUNC inline void initpacket(const Packet& p, Index, Index) { res = all_predux(p); }
|
|
EIGEN_DEVICE_FUNC inline void initpacket(const Packet& p, Index) { res = all_predux(p); }
|
|
EIGEN_DEVICE_FUNC inline void operator()(const Scalar& value, Index, Index) { res = res && (value != Scalar(0)); }
|
|
EIGEN_DEVICE_FUNC inline void operator()(const Scalar& value, Index) { res = res && (value != Scalar(0)); }
|
|
EIGEN_DEVICE_FUNC inline void packet(const Packet& p, Index, Index) { res = res && all_predux(p); }
|
|
EIGEN_DEVICE_FUNC inline void packet(const Packet& p, Index) { res = res && all_predux(p); }
|
|
EIGEN_DEVICE_FUNC inline bool done() const { return !res; }
|
|
bool res = true;
|
|
};
|
|
template <typename Scalar>
|
|
struct functor_traits<all_visitor<Scalar>> {
|
|
enum { Cost = NumTraits<Scalar>::ReadCost, LinearAccess = true, PacketAccess = packet_traits<Scalar>::HasCmp };
|
|
};
|
|
|
|
template <typename Scalar>
|
|
struct any_visitor {
|
|
using result_type = bool;
|
|
using Packet = typename packet_traits<Scalar>::type;
|
|
EIGEN_DEVICE_FUNC inline void init(const Scalar& value, Index, Index) { res = (value != Scalar(0)); }
|
|
EIGEN_DEVICE_FUNC inline void init(const Scalar& value, Index) { res = (value != Scalar(0)); }
|
|
EIGEN_DEVICE_FUNC inline bool any_predux(const Packet& p) const {
|
|
return predux_any(pandnot(ptrue(p), pcmp_eq(p, pzero(p))));
|
|
}
|
|
EIGEN_DEVICE_FUNC inline void initpacket(const Packet& p, Index, Index) { res = any_predux(p); }
|
|
EIGEN_DEVICE_FUNC inline void initpacket(const Packet& p, Index) { res = any_predux(p); }
|
|
EIGEN_DEVICE_FUNC inline void operator()(const Scalar& value, Index, Index) { res = res || (value != Scalar(0)); }
|
|
EIGEN_DEVICE_FUNC inline void operator()(const Scalar& value, Index) { res = res || (value != Scalar(0)); }
|
|
EIGEN_DEVICE_FUNC inline void packet(const Packet& p, Index, Index) { res = res || any_predux(p); }
|
|
EIGEN_DEVICE_FUNC inline void packet(const Packet& p, Index) { res = res || any_predux(p); }
|
|
EIGEN_DEVICE_FUNC inline bool done() const { return res; }
|
|
bool res = false;
|
|
};
|
|
template <typename Scalar>
|
|
struct functor_traits<any_visitor<Scalar>> {
|
|
enum { Cost = NumTraits<Scalar>::ReadCost, LinearAccess = true, PacketAccess = packet_traits<Scalar>::HasCmp };
|
|
};
|
|
|
|
template <typename Scalar>
|
|
struct count_visitor {
|
|
using result_type = Index;
|
|
using Packet = typename packet_traits<Scalar>::type;
|
|
EIGEN_DEVICE_FUNC inline void init(const Scalar& value, Index, Index) { res = value != Scalar(0) ? 1 : 0; }
|
|
EIGEN_DEVICE_FUNC inline void init(const Scalar& value, Index) { res = value != Scalar(0) ? 1 : 0; }
|
|
EIGEN_DEVICE_FUNC inline Index count_redux(const Packet& p) const {
|
|
const Packet cst_one = pset1<Packet>(Scalar(1));
|
|
Packet true_vals = pandnot(cst_one, pcmp_eq(p, pzero(p)));
|
|
Scalar num_true = predux(true_vals);
|
|
return static_cast<Index>(num_true);
|
|
}
|
|
EIGEN_DEVICE_FUNC inline void initpacket(const Packet& p, Index, Index) { res = count_redux(p); }
|
|
EIGEN_DEVICE_FUNC inline void initpacket(const Packet& p, Index) { res = count_redux(p); }
|
|
EIGEN_DEVICE_FUNC inline void operator()(const Scalar& value, Index, Index) {
|
|
if (value != Scalar(0)) res++;
|
|
}
|
|
EIGEN_DEVICE_FUNC inline void operator()(const Scalar& value, Index) {
|
|
if (value != Scalar(0)) res++;
|
|
}
|
|
EIGEN_DEVICE_FUNC inline void packet(const Packet& p, Index, Index) { res += count_redux(p); }
|
|
EIGEN_DEVICE_FUNC inline void packet(const Packet& p, Index) { res += count_redux(p); }
|
|
Index res = 0;
|
|
};
|
|
|
|
template <typename Scalar>
|
|
struct functor_traits<count_visitor<Scalar>> {
|
|
enum {
|
|
Cost = NumTraits<Scalar>::AddCost,
|
|
LinearAccess = true,
|
|
// predux is problematic for bool
|
|
PacketAccess = packet_traits<Scalar>::HasCmp && packet_traits<Scalar>::HasAdd && !is_same<Scalar, bool>::value
|
|
};
|
|
};
|
|
|
|
} // end namespace internal
|
|
|
|
/** \fn DenseBase<Derived>::minCoeff(IndexType* rowId, IndexType* colId) const
|
|
* \returns the minimum of all coefficients of *this and puts in *row and *col its location.
|
|
*
|
|
* In case \c *this contains NaN, NaNPropagation determines the behavior:
|
|
* NaNPropagation == PropagateFast : undefined
|
|
* NaNPropagation == PropagateNaN : result is NaN
|
|
* NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN
|
|
* \warning the matrix must be not empty, otherwise an assertion is triggered.
|
|
*
|
|
* \sa DenseBase::minCoeff(Index*), DenseBase::maxCoeff(Index*,Index*), DenseBase::visit(), DenseBase::minCoeff()
|
|
*/
|
|
template<typename Derived>
|
|
template<int NaNPropagation, typename IndexType>
|
|
EIGEN_DEVICE_FUNC
|
|
typename internal::traits<Derived>::Scalar
|
|
DenseBase<Derived>::minCoeff(IndexType* rowId, IndexType* colId) const
|
|
{
|
|
eigen_assert(this->rows()>0 && this->cols()>0 && "you are using an empty matrix");
|
|
|
|
internal::minmax_coeff_visitor<Derived, true, NaNPropagation> minVisitor;
|
|
this->visit(minVisitor);
|
|
*rowId = minVisitor.row;
|
|
if (colId) *colId = minVisitor.col;
|
|
return minVisitor.res;
|
|
}
|
|
|
|
/** \returns the minimum of all coefficients of *this and puts in *index its location.
|
|
*
|
|
* In case \c *this contains NaN, NaNPropagation determines the behavior:
|
|
* NaNPropagation == PropagateFast : undefined
|
|
* NaNPropagation == PropagateNaN : result is NaN
|
|
* NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN
|
|
* \warning the matrix must be not empty, otherwise an assertion is triggered.
|
|
*
|
|
* \sa DenseBase::minCoeff(IndexType*,IndexType*), DenseBase::maxCoeff(IndexType*,IndexType*), DenseBase::visit(), DenseBase::minCoeff()
|
|
*/
|
|
template<typename Derived>
|
|
template<int NaNPropagation, typename IndexType>
|
|
EIGEN_DEVICE_FUNC
|
|
typename internal::traits<Derived>::Scalar
|
|
DenseBase<Derived>::minCoeff(IndexType* index) const
|
|
{
|
|
eigen_assert(this->rows() > 0 && this->cols() > 0 && "you are using an empty matrix");
|
|
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
|
|
|
|
internal::minmax_coeff_visitor<Derived, true, NaNPropagation> minVisitor;
|
|
this->visit(minVisitor);
|
|
*index = IndexType((RowsAtCompileTime==1) ? minVisitor.col : minVisitor.row);
|
|
return minVisitor.res;
|
|
}
|
|
|
|
/** \fn DenseBase<Derived>::maxCoeff(IndexType* rowId, IndexType* colId) const
|
|
* \returns the maximum of all coefficients of *this and puts in *row and *col its location.
|
|
*
|
|
* In case \c *this contains NaN, NaNPropagation determines the behavior:
|
|
* NaNPropagation == PropagateFast : undefined
|
|
* NaNPropagation == PropagateNaN : result is NaN
|
|
* NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN
|
|
* \warning the matrix must be not empty, otherwise an assertion is triggered.
|
|
*
|
|
* \sa DenseBase::minCoeff(IndexType*,IndexType*), DenseBase::visit(), DenseBase::maxCoeff()
|
|
*/
|
|
template<typename Derived>
|
|
template<int NaNPropagation, typename IndexType>
|
|
EIGEN_DEVICE_FUNC
|
|
typename internal::traits<Derived>::Scalar
|
|
DenseBase<Derived>::maxCoeff(IndexType* rowPtr, IndexType* colPtr) const
|
|
{
|
|
eigen_assert(this->rows()>0 && this->cols()>0 && "you are using an empty matrix");
|
|
|
|
internal::minmax_coeff_visitor<Derived, false, NaNPropagation> maxVisitor;
|
|
this->visit(maxVisitor);
|
|
*rowPtr = maxVisitor.row;
|
|
if (colPtr) *colPtr = maxVisitor.col;
|
|
return maxVisitor.res;
|
|
}
|
|
|
|
/** \returns the maximum of all coefficients of *this and puts in *index its location.
|
|
*
|
|
* In case \c *this contains NaN, NaNPropagation determines the behavior:
|
|
* NaNPropagation == PropagateFast : undefined
|
|
* NaNPropagation == PropagateNaN : result is NaN
|
|
* NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN
|
|
* \warning the matrix must be not empty, otherwise an assertion is triggered.
|
|
*
|
|
* \sa DenseBase::maxCoeff(IndexType*,IndexType*), DenseBase::minCoeff(IndexType*,IndexType*), DenseBase::visitor(), DenseBase::maxCoeff()
|
|
*/
|
|
template<typename Derived>
|
|
template<int NaNPropagation, typename IndexType>
|
|
EIGEN_DEVICE_FUNC
|
|
typename internal::traits<Derived>::Scalar
|
|
DenseBase<Derived>::maxCoeff(IndexType* index) const
|
|
{
|
|
eigen_assert(this->rows()>0 && this->cols()>0 && "you are using an empty matrix");
|
|
|
|
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
|
|
internal::minmax_coeff_visitor<Derived, false, NaNPropagation> maxVisitor;
|
|
this->visit(maxVisitor);
|
|
*index = (RowsAtCompileTime==1) ? maxVisitor.col : maxVisitor.row;
|
|
return maxVisitor.res;
|
|
}
|
|
|
|
/** \returns true if all coefficients are true
|
|
*
|
|
* Example: \include MatrixBase_all.cpp
|
|
* Output: \verbinclude MatrixBase_all.out
|
|
*
|
|
* \sa any(), Cwise::operator<()
|
|
*/
|
|
template <typename Derived>
|
|
EIGEN_DEVICE_FUNC inline bool DenseBase<Derived>::all() const {
|
|
using Visitor = internal::all_visitor<Scalar>;
|
|
using impl = internal::visit_impl<Derived, Visitor, /*ShortCircuitEvaulation*/true>;
|
|
Visitor visitor;
|
|
impl::run(derived(), visitor);
|
|
return visitor.res;
|
|
}
|
|
|
|
/** \returns true if at least one coefficient is true
|
|
*
|
|
* \sa all()
|
|
*/
|
|
template <typename Derived>
|
|
EIGEN_DEVICE_FUNC inline bool DenseBase<Derived>::any() const {
|
|
using Visitor = internal::any_visitor<Scalar>;
|
|
using impl = internal::visit_impl<Derived, Visitor, /*ShortCircuitEvaulation*/true>;
|
|
Visitor visitor;
|
|
impl::run(derived(), visitor);
|
|
return visitor.res;
|
|
}
|
|
|
|
/** \returns the number of coefficients which evaluate to true
|
|
*
|
|
* \sa all(), any()
|
|
*/
|
|
template<typename Derived>
|
|
EIGEN_DEVICE_FUNC
|
|
Index DenseBase<Derived>::count() const
|
|
{
|
|
using Visitor = internal::count_visitor<Scalar>;
|
|
using impl = internal::visit_impl<Derived, Visitor, /*ShortCircuitEvaulation*/false>;
|
|
Visitor visitor;
|
|
impl::run(derived(), visitor);
|
|
return visitor.res;
|
|
|
|
}
|
|
|
|
template <typename Derived>
|
|
EIGEN_DEVICE_FUNC inline bool DenseBase<Derived>::hasNaN() const {
|
|
return derived().cwiseTypedNotEqual(derived()).any();
|
|
}
|
|
|
|
/** \returns true if \c *this contains only finite numbers, i.e., no NaN and no +/-INF values.
|
|
*
|
|
* \sa hasNaN()
|
|
*/
|
|
template <typename Derived>
|
|
EIGEN_DEVICE_FUNC inline bool DenseBase<Derived>::allFinite() const {
|
|
return derived().array().isFinite().all();
|
|
}
|
|
|
|
} // end namespace Eigen
|
|
|
|
#endif // EIGEN_VISITOR_H
|