11#ifndef EIGEN_SPARSE_APPROX_COMPARISONS_H
12#define EIGEN_SPARSE_APPROX_COMPARISONS_H
15#include "./InternalHeaderCheck.h"
21template <
typename Scalar,
bool UseScaledComparison>
22struct sparse_approx_comparison {
23 using RealScalar =
typename NumTraits<Scalar>::Real;
24 using Accumulator = RealScalar;
28 template <
typename DifferenceNorm2,
typename Scaled>
29 static bool compare(
const RealScalar& x2,
const RealScalar& y2, Index,
const RealScalar& prec,
30 const DifferenceNorm2& difference2,
const Scaled&) {
31 return difference2() <= prec * prec * numext::mini(x2, y2);
34 template <
typename X,
typename Y>
35 static bool isApprox(
const X& x,
const Y& y,
const RealScalar& prec) {
37 x.squaredNorm(), y.squaredNorm(), 0, prec, [&] { return (x - y).squaredNorm(); }, [] { return false; });
44template <
typename Scalar>
45struct sparse_approx_comparison<Scalar, true> {
46 using RealScalar =
typename NumTraits<Scalar>::Real;
47 using Accumulator =
typename stable_norm_accumulator<RealScalar>::type;
49 using Wide = std::conditional_t<NumTraits<Scalar>::IsComplex, std::complex<Accumulator>, Accumulator>;
50 using Dense = approx_comparison_impl<Scalar, true>;
54 template <
typename DifferenceNorm2,
typename Scaled>
55 static bool compare(
const Accumulator& x2,
const Accumulator& y2, Index size,
const RealScalar& prec,
56 const DifferenceNorm2& difference2,
const Scaled& scaled) {
57 const Accumulator minimum = numext::mini(x2, y2);
58 const Accumulator precision2 = Accumulator(prec) * Accumulator(prec);
59 const Accumulator bound = precision2 * minimum;
61 if (Dense::safe_squared_norm(bound, size) &&
62 minimum >= Dense::template squared_norm_lower_bound<RealScalar>(size) &&
63 precision2 >= Dense::template squared_norm_lower_bound<RealScalar>(1))
64 return Accumulator(difference2()) <= bound;
68 template <
typename X,
typename Y>
69 static bool isApprox(
const X& x,
const Y& y,
const RealScalar& prec) {
71 EIGEN_CHECK_BINARY_COMPATIBILITY(scalar_difference_op<typename X::Scalar EIGEN_COMMA typename Y::Scalar>,
72 typename X::Scalar,
typename Y::Scalar)
73 const auto& wideX = x.template cast<approx_comparison_wide_t<X>>();
74 const auto& wideY = y.template cast<approx_comparison_wide_t<Y>>();
77 wideX.squaredNorm(), wideY.squaredNorm(), stored_size(x) + stored_size(y), prec,
78 [&] {
return (wideX - wideY).squaredNorm(); }, [&] {
return isApprox_scaled(x, y, prec); });
83 template <typename X, std::enable_if_t<has_compressed_access<X>::value,
int> = 0>
84 static Index stored_size(
const X& x) {
87 template <typename X, std::enable_if_t<!has_compressed_access<X>::value,
int> = 0>
88 static Index stored_size(
const X& x) {
89 return x.rows() * x.cols();
93 template <
typename Plain>
94 static comparison_magnitude<Accumulator> norm(
const Plain& m) {
95 return scaled_comparison_norm(m.coeffs().matrix());
98 template <
typename X,
typename Y>
99 static EIGEN_DONT_INLINE
bool isApprox_scaled(
const X& xExpr,
const Y& yExpr,
const RealScalar& prec) {
101 using StorageIndex =
typename X::StorageIndex;
102 using WideX = approx_comparison_wide_t<X>;
103 using WideY = approx_comparison_wide_t<Y>;
104 using WideDifference = std::conditional_t<NumTraits<WideX>::IsComplex, WideX, WideY>;
105 const SparseMatrix<WideX, Order, StorageIndex> x = xExpr.template cast<WideX>();
106 const SparseMatrix<WideY, Order, StorageIndex> y = yExpr.template cast<WideY>();
107 const auto nx = norm(x);
108 const auto ny = norm(y);
109 if (!nx.isFinite() || !ny.isFinite())
return false;
110 auto tolerance = nx <= ny ? nx : ny;
111 tolerance.multiply(numext::abs(Accumulator(prec)));
115 const Accumulator maxCoeff =
116 numext::mini(Accumulator(1), numext::maxi(scaled_comparison_max_coeff(x.coeffs().matrix().realView()),
117 scaled_comparison_max_coeff(y.coeffs().matrix().realView())));
118 const safe_scaling_factors<Accumulator> factors = supports_power_of_two_scaling<Accumulator>::value
119 ? safe_scaling<Accumulator>::compute_floor_factors(maxCoeff)
120 : safe_scaling_factors<Accumulator>();
121 SparseMatrix<WideDifference, Order, StorageIndex> difference = x * factors.invScale - y * factors.invScale;
122 auto distance = norm(difference);
123 if (!distance.isFinite()) {
124 const Accumulator halfInvScale = factors.invScale * Accumulator(0.5);
125 difference = x * halfInvScale - y * halfInvScale;
126 distance = norm(difference);
127 distance.multiply(Accumulator(2));
129 distance.multiply(factors.scale);
130 return distance <= tolerance;
136template <
typename Derived>
137template <
typename OtherDerived>
139 const typename internal::nested_eval<Derived, 2, PlainObject>::type actualA(derived());
140 std::conditional_t<bool(IsRowMajor) == bool(OtherDerived::IsRowMajor),
141 const typename internal::nested_eval<OtherDerived, 2, PlainObject>::type,
const PlainObject>
142 actualB(other.derived());
144 return internal::sparse_approx_comparison<Scalar>::isApprox(actualA, actualB, prec);
Base class of any sparse matrices or sparse expressions.
Definition SparseMatrixBase.h:31
@ ColMajor
Definition Constants.h:319
@ RowMajor
Definition Constants.h:321