7#ifndef EIGEN_PREDICATOR_H
8#define EIGEN_PREDICATOR_H
11#include "./InternalHeaderCheck.h"
22template <
typename Scalar>
23struct nonzero_predicate {
24 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
bool operator()(
const Scalar& x)
const {
return x != Scalar(0); }
25 template <
typename Packet>
26 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& x)
const {
27 return pandnot(ptrue(x), pcmp_eq(x, pzero(x)));
30template <
typename Scalar>
31struct functor_traits<nonzero_predicate<Scalar>> {
32 static constexpr bool PacketAccess = packet_traits<Scalar>::HasCmp;
36 static constexpr bool GroupScalars =
true;
39template <
typename Scalar>
40struct isfinite_predicate {
41 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
bool operator()(
const Scalar& x)
const {
return (numext::isfinite)(x); }
42 template <
typename Packet>
43 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& x)
const {
47template <
typename Scalar>
48struct functor_traits<isfinite_predicate<Scalar>> {
49 static constexpr bool PacketAccess = packet_traits<Scalar>::HasCmp;
50 static constexpr bool GroupScalars =
true;
54template <
typename Scalar,
bool Approximate>
55struct fuzzy_constant_predicate {
56 using RealScalar =
typename NumTraits<Scalar>::Real;
59 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
bool operator()(
const Scalar& x)
const {
60 return internal::isApprox(x, value, precision);
65 template <
typename Packet>
66 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& x)
const {
67 const Packet bound = pset1<Packet>(numext::abs(value) * precision);
68 const Packet scale = pset1<Packet>(numext::copysign(precision, value));
69 return pcmp_le(pabs(psub(x, pset1<Packet>(value))), pmin(pmul(x, scale), bound));
71 EIGEN_DEVICE_FUNC
bool packetOpApplies()
const {
72 return precision >= RealScalar(0) && precision <= RealScalar(1) && (numext::isfinite)(value);
75template <
typename Scalar>
76struct fuzzy_constant_predicate<Scalar, false> {
78 typename NumTraits<Scalar>::Real precision;
79 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
bool operator()(
const Scalar& x)
const {
80 return internal::isMuchSmallerThan(x, Scalar(1), precision);
82 template <
typename Packet>
83 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& x)
const {
84 return pcmp_le(pabs(x), pset1<Packet>(precision));
87template <
typename Scalar,
bool Approximate>
88struct functor_traits<fuzzy_constant_predicate<Scalar, Approximate>> {
91 static constexpr bool PacketAccess =
92 (std::is_same<Scalar, float>::value || std::is_same<Scalar, double>::value) &&
93 !(EIGEN_ARCH_ARM && std::is_same<Scalar, float>::value) && packet_traits<Scalar>::HasAbs &&
94 packet_traits<Scalar>::HasCmp &&
96 (packet_traits<Scalar>::HasSub && packet_traits<Scalar>::HasMin && packet_traits<Scalar>::HasMul));
98 static constexpr bool GroupScalars = PacketAccess;
101 static constexpr int BlockPackets = Approximate ? 2 : 8;
105template <
typename Predicate>
106struct scalar_predicate {
108 template <
typename Scalar>
109 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
bool operator()(
const Scalar& x)
const {
113template <
typename Predicate>
114struct functor_traits<scalar_predicate<Predicate>> {
115 static constexpr bool PacketAccess =
false;
121struct packet_predicate {
122 template <
typename Predicate,
typename Packet>
123 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet apply(
const Predicate& pred,
const Packet& x) {
124 return pred.packetOp(x);
127template <
bool Target>
128struct predicate_search;
130struct predicate_search<true> : packet_predicate {
131 template <
typename Packet>
132 static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet combine(
const Packet& a,
const Packet& b) {
135 template <
typename Packet>
136 static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool found(
const Packet& m) {
137 return predux_any(m);
140 template <
typename Packet>
141 static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool found_in(
const Packet& m,
const Packet& lanes) {
142 return predux_any(pand(m, lanes));
144 template <
typename Predicate,
typename Scalar>
145 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
bool test_scalar(
const Predicate& pred,
const Scalar& x) {
150struct predicate_search<false> : packet_predicate {
151 template <
typename Packet>
152 static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet combine(
const Packet& a,
const Packet& b) {
156 template <
typename Packet>
157 static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool found(
const Packet& m) {
158 return predux_any(pandnot(ptrue(m), m));
160 template <
typename Packet>
161 static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool found_in(
const Packet& m,
const Packet& lanes) {
162 return predux_any(pandnot(lanes, m));
164 template <
typename Predicate,
typename Scalar>
165 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
bool test_scalar(
const Predicate& pred,
const Scalar& x) {
173struct zero_lane_search : predicate_search<true> {
174 template <
typename Predicate,
typename Packet>
175 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet apply(
const Predicate&,
const Packet& x) {
176 return pcmp_eq(x, pzero(x));
178 template <
typename Predicate,
typename Scalar>
179 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
bool test_scalar(
const Predicate& pred,
const Scalar& x) {
184struct bool_lane_search : predicate_search<true> {
185 template <
typename Predicate,
typename Packet>
186 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet apply(
const Predicate&,
const Packet& x) {
193struct or_lane_search : predicate_search<true> {
194 template <
typename Predicate,
typename Packet>
195 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet apply(
const Predicate&,
const Packet& x) {
198 template <
typename Packet>
199 static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool found(
const Packet& m) {
200 return predux_any(pandnot(ptrue(m), pcmp_eq(m, pzero(m))));
202 template <
typename Packet>
203 static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool found_in(
const Packet& m,
const Packet& lanes) {
204 return found(pand(m, lanes));
207template <
bool Target,
typename Predicate>
208struct predicate_search_for {
209 using type = predicate_search<Target>;
211template <
typename Scalar>
212struct predicate_search_for<false, nonzero_predicate<Scalar>> {
213 using type = zero_lane_search;
215template <
typename Scalar>
216struct predicate_search_for<true, nonzero_predicate<Scalar>> {
217 using type = std::conditional_t<std::is_integral<Scalar>::value, or_lane_search, predicate_search<true>>;
220struct predicate_search_for<true, nonzero_predicate<bool>> {
221 using type = bool_lane_search;
225template <
typename Evaluator,
bool Linear = Evaluator::LinearAccess>
226struct predicate_segment {
227 using Scalar =
typename Evaluator::Scalar;
228 static constexpr bool FixedSize = Evaluator::RowsAtCompileTime > 0 && Evaluator::ColsAtCompileTime > 0;
229 static constexpr bool PlainLoad = int(Evaluator::CoeffReadCost) <= int(NumTraits<Scalar>::ReadCost);
230 const Evaluator& eval;
232 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE predicate_segment(
const Evaluator& evaluator, Index, Index size)
233 : eval(evaluator), length(size) {}
234 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index size()
const {
return length; }
235 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
typename Evaluator::CoeffReturnType coeff(Index i)
const {
236 return eval.coeff(i);
238 template <
typename Packet>
239 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packet(Index i)
const {
240 return eval.template packet<Packet>(i);
242 template <
typename Packet>
243 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetSegment(Index i, Index count)
const {
244 return eval.template packetSegment<Packet>(i, 0, count);
247template <
typename Evaluator>
248struct predicate_segment<Evaluator, false> {
249 using Scalar =
typename Evaluator::Scalar;
250 static constexpr bool FixedSize =
251 (Evaluator::IsRowMajor ? Evaluator::ColsAtCompileTime : Evaluator::RowsAtCompileTime) > 0;
252 static constexpr bool PlainLoad = int(Evaluator::CoeffReadCost) <= int(NumTraits<Scalar>::ReadCost);
253 const Evaluator& eval;
256 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE predicate_segment(
const Evaluator& evaluator, Index j, Index size)
257 : eval(evaluator), outer(j), length(size) {}
258 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index size()
const {
return length; }
259 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
typename Evaluator::CoeffReturnType coeff(Index i)
const {
260 return Evaluator::IsRowMajor ? eval.coeff(outer, i) : eval.coeff(i, outer);
262 template <
typename Packet>
263 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packet(Index i)
const {
264 return Evaluator::IsRowMajor ? eval.template packet<Packet>(outer, i) : eval.template packet<Packet>(i, outer);
266 template <
typename Packet>
267 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetSegment(Index i, Index count)
const {
268 return Evaluator::IsRowMajor ? eval.template packetSegment<Packet>(outer, i, 0, count)
269 : eval.template packetSegment<Packet>(i, outer, 0, count);
274template <
typename Predicate,
typename =
void>
275struct predicate_groups_scalars : std::false_type {};
276template <
typename Predicate>
277struct predicate_groups_scalars<Predicate, void_t<decltype(functor_traits<Predicate>::GroupScalars)>>
278 : bool_constant<static_cast<bool>(functor_traits<Predicate>::GroupScalars)> {};
281template <
typename Predicate,
typename =
void>
282struct predicate_block_packets : std::integral_constant<int, 8> {};
283template <
typename Predicate>
284struct predicate_block_packets<Predicate, void_t<decltype(functor_traits<Predicate>::BlockPackets)>>
285 : std::integral_constant<int, functor_traits<Predicate>::BlockPackets> {};
289EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
bool predicate_or(
bool a,
bool b) {
return a | b; }
292template <
typename Search,
typename Segment,
typename Predicate>
293EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool predicate_search_upto3(
const Segment& seg, Index i, Predicate pred) {
294 const Index size = seg.size();
295 if (i == size)
return false;
296 bool b = Search::test_scalar(pred, seg.coeff(i));
297 if (i + 1 < size) b = predicate_or(b, Search::test_scalar(pred, seg.coeff(i + 1)));
298 if (i + 2 < size) b = predicate_or(b, Search::test_scalar(pred, seg.coeff(i + 2)));
302template <
typename Search,
typename Segment,
typename Predicate>
303EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool predicate_search_scalar(
const Segment& seg, Index i, Predicate pred) {
304 const Index size = seg.size();
305 for (; i + 3 < size; i += 4) {
306 bool b = predicate_or(
307 predicate_or(Search::test_scalar(pred, seg.coeff(i)), Search::test_scalar(pred, seg.coeff(i + 1))),
308 predicate_or(Search::test_scalar(pred, seg.coeff(i + 2)), Search::test_scalar(pred, seg.coeff(i + 3))));
309 if EIGEN_PREDICT_FALSE (b)
return true;
311 return predicate_search_upto3<Search>(seg, i, pred);
315template <
typename Search,
typename Segment,
typename Predicate>
316EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
bool predicate_search_sequential(
const Segment& seg, Index i, Predicate pred) {
317 for (
const Index size = seg.size(); i < size; ++i)
318 if (Search::test_scalar(pred, seg.coeff(i)))
return true;
324template <
typename Search,
typename Segment,
typename Predicate>
325EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool predicate_search_tail(
const Segment& seg, Index i, Predicate pred) {
326 if (predicate_groups_scalars<Predicate>::value)
return predicate_search_scalar<Search>(seg, i, pred);
327 return predicate_search_sequential<Search>(seg, i, pred);
332template <
typename Scalar,
typename Un
signed =
typename numext::get_
integer_by_size<sizeof(Scalar)>::
unsigned_type>
333struct predicate_block_accumulator {
334 using type = Unsigned;
336template <
typename Scalar>
337struct predicate_block_accumulator<Scalar, void> {
341template <
typename Search,
typename Packet,
bool Vectorize>
342struct predicate_search_segment {
343 static constexpr Index ShortSize = 0;
347 template <
typename Segment,
typename Predicate>
348 static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool run(
const Segment& seg, Predicate pred) {
349 if (!predicate_groups_scalars<Predicate>::value)
return predicate_search_sequential<Search>(seg, 0, pred);
350 const Index size = seg.size();
352 if (EIGEN_PREDICT_FALSE(size < 4))
return predicate_search_upto3<Search>(seg, 0, pred);
354 using Acc =
typename predicate_block_accumulator<typename Segment::Scalar>::type;
355 for (; i + 64 <= size; i += 64) {
357 for (Index k = 0; k < 64; ++k) b |= Acc(Search::test_scalar(pred, seg.coeff(i + k)));
358 if EIGEN_PREDICT_FALSE (b != Acc(0)) return true;
360 return predicate_search_scalar<Search>(seg, i, pred);
362 template <typename Segment, typename Predicate>
363 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
bool run_short(const Segment& seg, Predicate pred) {
364 return run(seg, pred);
370template <
typename Packet,
typename Bytes = std::make_index_sequence<2 * sizeof(Packet)>>
371struct predicate_lane_table;
372template <
typename Packet, std::size_t... Byte>
373struct predicate_lane_table<Packet, std::index_sequence<Byte...>> {
374 using Scalar =
typename unpacket_traits<Packet>::type;
375 static constexpr Index Size = unpacket_traits<Packet>::size;
377 alignas(
sizeof(Packet))
static constexpr unsigned char table[2 *
sizeof(Packet)] = {
378 (Byte <
sizeof(Packet) ? 0xff : 0)...};
379 static EIGEN_STRONG_INLINE Packet first(Index count) {
380 return ploadu<Packet>(
reinterpret_cast<const Scalar*
>(table + (Size - count) *
sizeof(Scalar)));
383#if EIGEN_COMP_CXXVER < 17
384template <
typename Packet, std::size_t... Byte>
385alignas(
sizeof(Packet))
constexpr unsigned char predicate_lane_table<Packet, std::index_sequence<Byte...>>::table[];
388template <
typename Search,
typename Packet>
389struct predicate_search_segment<Search, Packet, true> {
392 template <
typename Segment,
typename Predicate>
393 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet test(
const Segment& seg, Index i,
const Predicate& pred) {
394 return Search::apply(pred, seg.template packet<Packet>(i));
396 static constexpr Index PacketSize = unpacket_traits<Packet>::size;
398 static constexpr Index ShortSize = 4 * PacketSize;
401 template <
typename Segment,
typename Predicate>
402 static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool run_short(
const Segment& seg, Predicate pred) {
403 const Index size = seg.size();
405 if (PacketSize <= size) {
406 if (size < 2 * PacketSize) {
407 if (Search::found(test(seg, 0, pred)))
return true;
409 }
else if (size < 3 * PacketSize) {
410 if (Search::found(Search::combine(test(seg, 0, pred), test(seg, PacketSize, pred))))
return true;
413 if (Search::found(Search::combine(Search::combine(test(seg, 0, pred), test(seg, PacketSize, pred)),
414 test(seg, 2 * PacketSize, pred))))
418 if (EIGEN_PREDICT_TRUE(i == size))
return false;
419 }
else if (has_packet_segment<Packet>::value && Segment::PlainLoad && (Segment::FixedSize || size >= 4)) {
420 return run_partial(seg, pred, bool_constant<has_packet_segment<Packet>::value>());
421 }
else if (size < 4 && predicate_groups_scalars<Predicate>::value) {
423 return predicate_search_upto3<Search>(seg, 0, pred);
425 return predicate_search_tail<Search>(seg, i, pred);
433 template <
typename Segment,
typename Predicate>
434 static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool run_partial(
const Segment& seg, Predicate pred, std::true_type) {
435 const Index size = seg.size();
436 return Search::found_in(Search::apply(pred, seg.template packetSegment<Packet>(0, size)),
437 predicate_lane_table<Packet>::first(size));
439 template <
typename Segment,
typename Predicate>
440 static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool run_partial(
const Segment& seg, Predicate pred, std::false_type) {
441 return predicate_search_tail<Search>(seg, 0, pred);
444 template <
int Block,
typename Segment,
typename Predicate>
445 static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool run_blocks(
const Segment& seg, Predicate pred) {
446 const Index size = seg.size();
448 for (; i + Block * PacketSize <= size; i += Block * PacketSize) {
449 Packet m = test(seg, i, pred);
450 for (
int k = 1; k < Block; ++k) m = Search::combine(m, test(seg, i + k * PacketSize, pred));
451 if EIGEN_PREDICT_FALSE (Search::found(m))
return true;
453 if (Block > 1 && i + PacketSize <= size) {
454 Packet m = test(seg, i, pred);
455 for (i += PacketSize; i + PacketSize <= size; i += PacketSize) m = Search::combine(m, test(seg, i, pred));
456 if (Search::found(m))
return true;
458 if (EIGEN_PREDICT_TRUE(i == size))
return false;
459 return predicate_search_tail<Search>(seg, i, pred);
462 template <
typename Segment,
typename Predicate>
463 static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool run(
const Segment& seg, Predicate pred) {
464 const Index size = seg.size();
465 if (size < ShortSize)
return run_short(seg, pred);
466 EIGEN_IF_CONSTEXPR (predicate_block_packets<Predicate>::value < 8) {
467 return run_blocks<predicate_block_packets<Predicate>::value>(seg, pred);
471 if (EIGEN_PREDICT_FALSE(8 * PacketSize <= size)) {
473 Packet m = Search::combine(
474 Search::combine(Search::combine(test(seg, i + 0 * PacketSize, pred), test(seg, i + 1 * PacketSize, pred)),
475 Search::combine(test(seg, i + 2 * PacketSize, pred), test(seg, i + 3 * PacketSize, pred))),
476 Search::combine(Search::combine(test(seg, i + 4 * PacketSize, pred), test(seg, i + 5 * PacketSize, pred)),
477 Search::combine(test(seg, i + 6 * PacketSize, pred), test(seg, i + 7 * PacketSize, pred))));
478 if EIGEN_PREDICT_FALSE (Search::found(m))
return true;
480 }
while (i + 8 * PacketSize <= size);
482 if (i + 4 * PacketSize <= size) {
484 Search::combine(Search::combine(test(seg, i + 0 * PacketSize, pred), test(seg, i + 1 * PacketSize, pred)),
485 Search::combine(test(seg, i + 2 * PacketSize, pred), test(seg, i + 3 * PacketSize, pred)));
486 if (Search::found(m))
return true;
489 if (i + PacketSize <= size) {
490 Packet m = test(seg, i, pred);
491 for (i += PacketSize; i + PacketSize <= size; i += PacketSize) m = Search::combine(m, test(seg, i, pred));
492 if (Search::found(m))
return true;
494 if (EIGEN_PREDICT_TRUE(i == size))
return false;
495 return predicate_search_tail<Search>(seg, i, pred);
499template <
typename Derived,
typename Predicate>
500struct predicate_reduction {
501 using Evaluator = visitor_evaluator<Derived>;
502 using Scalar =
typename Derived::Scalar;
503 static constexpr bool LinearAccess = Evaluator::LinearAccess;
505 static constexpr int SegmentSizeAtCompileTime =
506 LinearAccess ? int(Derived::SizeAtCompileTime)
507 : int(Evaluator::IsRowMajor ? Derived::ColsAtCompileTime : Derived::RowsAtCompileTime);
508 using Packet =
typename find_largest_packet<Scalar, SegmentSizeAtCompileTime>::type;
509 static constexpr bool Vectorize = Evaluator::PacketAccess && packet_traits<Scalar>::Vectorizable &&
510 (unpacket_traits<Packet>::size > 1) &&
511 static_cast<bool>(functor_traits<Predicate>::PacketAccess);
512 using Segment = predicate_segment<Evaluator>;
514 template <
bool Target>
515 static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool search(
const Derived& xpr, Predicate pred) {
516 using impl = predicate_search_segment<typename predicate_search_for<Target, Predicate>::type, Packet, Vectorize>;
518 EIGEN_IF_CONSTEXPR (LinearAccess) {
519 return impl::run(Segment(eval, 0, eval.size()), pred);
523 const Index innerSize = Evaluator::IsRowMajor ? eval.cols() : eval.rows();
524 const Index outerSize = Evaluator::IsRowMajor ? eval.rows() : eval.cols();
526 if (innerSize < impl::ShortSize) {
527 for (Index j = 0; j < outerSize; ++j)
528 if (impl::run_short(Segment(eval, j, innerSize), pred))
return true;
530 for (Index j = 0; j < outerSize; ++j)
531 if (impl::run(Segment(eval, j, innerSize), pred))
return true;
539template <
typename Derived,
typename Predicate>
540EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool all_of(
const Derived& xpr,
const Predicate& pred) {
541 return !predicate_reduction<Derived, Predicate>::template search<false>(xpr, pred);
545template <
typename Derived,
typename Predicate>
546EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool any_of(
const Derived& xpr,
const Predicate& pred) {
547 return predicate_reduction<Derived, Predicate>::template search<true>(xpr, pred);
551template <
typename Derived,
typename Predicate>
552EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool fuzzy_constant_all_of(
const Derived& xpr,
const Predicate& pred,
554 if (EIGEN_PREDICT_FALSE(!pred.packetOpApplies()))
return all_of(xpr, scalar_predicate<Predicate>{pred});
555 return all_of(xpr, pred);
557template <
typename Derived,
typename Predicate>
558EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool fuzzy_constant_all_of(
const Derived& xpr,
const Predicate& pred,
560 return all_of(xpr, pred);
563template <typename Derived, bool AlwaysTrue = NumTraits<typename traits<Derived>::Scalar>::IsInteger>
564struct all_finite_impl {
565 static EIGEN_DEVICE_FUNC
inline bool run(
const Derived& ) {
return true; }
567#if !defined(__FINITE_MATH_ONLY__) || !(__FINITE_MATH_ONLY__)
568template <
typename Derived>
569struct all_finite_impl<Derived, false> {
570 static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool run(
const Derived& derived) {
571 return all_of(derived, isfinite_predicate<
typename traits<Derived>::Scalar>());
585template <
typename Derived>
587 return internal::all_of(derived(), internal::nonzero_predicate<Scalar>());
594template <
typename Derived>
596 return internal::any_of(derived(), internal::nonzero_predicate<Scalar>());
599template <
typename Derived>
600EIGEN_DEVICE_FUNC
inline bool DenseBase<Derived>::hasNaN()
const {
601 return derived().cwiseTypedNotEqual(derived()).any();
608template <
typename Derived>
610 return internal::all_finite_impl<Derived>::run(derived());
614template <
typename Derived>
616 const RealScalar& prec)
const {
617 using Predicate = internal::fuzzy_constant_predicate<Scalar, true>;
618 return internal::fuzzy_constant_all_of(
619 derived(), Predicate{val, prec},
620 std::integral_constant<bool, internal::functor_traits<Predicate>::PacketAccess>());
631template <
typename Derived>
633 return internal::all_of(derived(), internal::fuzzy_constant_predicate<Scalar, false>{
Scalar(0), prec});
bool isApproxToConstant(const Scalar &value, const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const
Definition Predicator.h:615
bool isZero(const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const
Definition Predicator.h:632
bool all() const
Definition Predicator.h:586
bool any() const
Definition Predicator.h:595
bool allFinite() const
Definition Predicator.h:609
typename internal::traits< ArrayWrapper< ExpressionType > >::Scalar Scalar
Definition DenseBase.h:63