11#ifndef EIGEN_TRIDIAGONAL_INVERSE_ITERATION_H
12#define EIGEN_TRIDIAGONAL_INVERSE_ITERATION_H
14#include "./SelfAdjointEigenSolver.h"
16#include "./TridiagonalBisection.h"
19#include "./InternalHeaderCheck.h"
35struct inverse_iteration_rng {
36 numext::uint64_t state;
38 explicit inverse_iteration_rng(numext::uint64_t seed) : state(seed) {}
40 template <
typename RealScalar>
45 state += 0x9E3779B97F4A7C15ULL;
46 const numext::uint64_t z = splitmix64_mix(state);
51 const numext::uint32_t hi = numext::uint32_t(z >> 32);
52 const RealScalar u = RealScalar(hi) * (RealScalar(1) / RealScalar(4294967296.0));
53 return RealScalar(2) * u - RealScalar(1);
84template <
typename RealScalar>
85void tridiagonal_lagtf(RealScalar* d, RealScalar* du, RealScalar* dl, RealScalar* du2, Index* piv, RealScalar lambda,
91 RealScalar scale1 = numext::abs(d[0]) + numext::abs(du[0]);
92 for (Index k = 0; k < n - 1; ++k) {
94 RealScalar scale2 = numext::abs(dl[k]) + numext::abs(d[k + 1]);
95 if (k < n - 2) scale2 += numext::abs(du[k + 1]);
97 const RealScalar piv1 = numext::is_exactly_zero(d[k]) ? RealScalar(0) : numext::abs(d[k]) / scale1;
98 if (numext::is_exactly_zero(dl[k])) {
101 if (k < n - 2) du2[k] = RealScalar(0);
103 const RealScalar piv2 = numext::abs(dl[k]) / scale2;
108 dl[k] = dl[k] / d[k];
109 d[k + 1] -= dl[k] * du[k];
110 if (k < n - 2) du2[k] = RealScalar(0);
114 const RealScalar mult = d[k] / dl[k];
116 const RealScalar temp = d[k + 1];
117 d[k + 1] = du[k] - mult * temp;
120 du[k + 1] = -mult * du2[k];
150template <
typename RealScalar>
151void tridiagonal_lagts(
const RealScalar* d,
const RealScalar* rcp,
const RealScalar* du,
const RealScalar* dl,
152 const RealScalar* du2,
const Index* piv, RealScalar* b, Index n) {
153 const RealScalar eps = NumTraits<RealScalar>::epsilon();
154 const RealScalar sfmin = (std::numeric_limits<RealScalar>::min)();
155 const RealScalar bignum = RealScalar(1) / sfmin;
158 using ArrayBuf = Map<const Array<RealScalar, Dynamic, 1>>;
159 RealScalar tol = ArrayBuf(d, n).abs().maxCoeff();
160 if (n > 1) tol = numext::maxi(tol, ArrayBuf(du, n - 1).abs().maxCoeff());
161 if (n > 2) tol = numext::maxi(tol, ArrayBuf(du2, n - 2).abs().maxCoeff());
163 if (numext::is_exactly_zero(tol)) tol = eps;
168 for (Index k = 1; k < n; ++k) {
169 const RealScalar dlk = dl[k - 1];
170 const RealScalar bkm1 = b[k - 1];
171 const RealScalar bk = b[k];
172 const bool interchange = piv[k - 1] != 0;
173 b[k - 1] = interchange ? bk : bkm1;
174 b[k] = interchange ? (bkm1 - dlk * bk) : (bk - dlk * bkm1);
183 for (Index k = n - 1; k >= 0; --k) {
184 RealScalar temp = b[k];
185 if (k <= n - 2) temp -= du[k] * b[k + 1];
186 if (k <= n - 3) temp -= du2[k] * b[k + 2];
187 const RealScalar ak = d[k];
188 const RealScalar absak = numext::abs(ak);
189 if (EIGEN_PREDICT_TRUE(absak >= RealScalar(1) || (absak >= sfmin && numext::abs(temp) <= absak * bignum))) {
190 b[k] = temp * rcp[k];
195 RealScalar pert = (a >= RealScalar(0)) ? tol : -tol;
197 const RealScalar aa = numext::abs(a);
198 if (aa < RealScalar(1)) {
200 if (numext::is_exactly_zero(aa) || numext::abs(t) * sfmin > aa) {
202 pert *= RealScalar(2);
208 }
else if (numext::abs(t) > aa * bignum) {
210 pert *= RealScalar(2);
247template <
typename RealScalar,
typename EivecType>
248Index tridiagonal_inverse_iteration_block(
const RealScalar* sdiag,
const RealScalar* ssub,
const RealScalar* xj_scaled,
249 const Index* clstart, Index n, RealScalar onenrm, RealScalar dtpcrt,
250 int maxits,
int extra, EivecType& eivecs, Index j_lo, Index j_hi) {
251 using RealVectorType = Matrix<RealScalar, Dynamic, 1>;
252 const RealScalar eps = NumTraits<RealScalar>::epsilon();
257 RealVectorType lu_d(n), lu_dl(n), lu_du(n), lu_du2(n), lu_rcp(n), b(n);
258 Matrix<Index, Dynamic, 1> piv(n);
261 for (Index j = j_lo; j < j_hi; ++j) {
262 const RealScalar xj = xj_scaled[j];
263 const Index gpind = clstart[j];
266 lu_d = Map<const RealVectorType>(sdiag, n);
267 lu_du.head(n - 1) = Map<const RealVectorType>(ssub, n - 1);
268 lu_dl.head(n - 1) = Map<const RealVectorType>(ssub, n - 1);
269 tridiagonal_lagtf<RealScalar>(lu_d.data(), lu_du.data(), lu_dl.data(), lu_du2.data(), piv.data(), xj, n);
272 lu_rcp.array() = RealScalar(1) / lu_d.array();
275 inverse_iteration_rng rng(numext::uint64_t(j) + 1);
276 for (Index i = 0; i < n; ++i) b[i] = rng.template next<RealScalar>();
279 bool converged =
false;
280 for (
int its = 0; its < maxits; ++its) {
282 const RealScalar bmax = b.cwiseAbs().maxCoeff();
283 if (numext::is_exactly_zero(bmax))
break;
284 const RealScalar target = RealScalar(n) * onenrm * numext::maxi(eps, numext::abs(lu_d[n - 1]));
285 const RealScalar scl = target / bmax;
286 if (EIGEN_PREDICT_TRUE(scl >= (std::numeric_limits<RealScalar>::min)())) {
295 tridiagonal_lagts<RealScalar>(lu_d.data(), lu_rcp.data(), lu_du.data(), lu_dl.data(), lu_du2.data(), piv.data(),
299 for (Index i = gpind; i < j; ++i) b -= b.dot(eivecs.col(i)) * eivecs.col(i);
301 const RealScalar nrm = b.cwiseAbs().maxCoeff();
302 if (nrm < dtpcrt)
continue;
303 if (++nrmchk < extra + 1)
continue;
309 if (!converged) ++nonconv;
315 const RealScalar binf = b.cwiseAbs().maxCoeff(&jmax);
316 safe_scaling<RealScalar>::scale_to(b, b, binf);
317 const RealScalar nrm2 = b.norm();
318 RealScalar scl = numext::is_exactly_zero(nrm2) ? RealScalar(1) : RealScalar(1) / nrm2;
319 if (b[jmax] < RealScalar(0)) scl = -scl;
320 eivecs.col(j) = b * scl;
346template <
typename DiagType,
typename SubdiagType,
typename EivalType,
typename EivecType>
347Index tridiagonal_inverse_iteration_connected(
const DiagType& diag,
const SubdiagType& subdiag,
const EivalType& eivals,
349 using RealScalar =
typename DiagType::Scalar;
350 EIGEN_STATIC_ASSERT(NumTraits<RealScalar>::IsInteger == 0 && NumTraits<RealScalar>::IsComplex == 0,
351 THIS_FUNCTION_IS_NOT_FOR_INTEGER_OR_COMPLEX_TYPES)
353 const Index n = diag.size();
354 const Index m = eivals.size();
355 if (n == 0 || m == 0)
return 0;
361 const RealScalar eps = NumTraits<RealScalar>::epsilon();
366 const RealScalar maxCoeff = max_preserving_subnormals(
367 safe_scaling<RealScalar>::recover_flushed_max_coeff(diag, diag.cwiseAbs().maxCoeff()),
368 safe_scaling<RealScalar>::recover_flushed_max_coeff(subdiag, subdiag.cwiseAbs().maxCoeff()));
369 Matrix<RealScalar, Dynamic, 1> sdiag(n), ssub(n - 1);
370 const auto factors = safe_scaling<RealScalar>::scale_to(sdiag, diag, maxCoeff);
371 safe_scaling<RealScalar>::scale_to(ssub, subdiag, maxCoeff, factors);
372 Matrix<RealScalar, Dynamic, 1> xj_scaled(m);
373 safe_scaling<RealScalar>::scale_to(xj_scaled, eivals, maxCoeff, factors);
374 if (maxCoeff > RealScalar(0) && maxCoeff < (std::numeric_limits<RealScalar>::min)()) {
377 const RealScalar scaledMax = numext::maxi(sdiag.cwiseAbs().maxCoeff(), ssub.cwiseAbs().maxCoeff());
378 const auto remaining = safe_scaling<RealScalar>::scale_in_place(sdiag, scaledMax);
379 safe_scaling<RealScalar>::scale_in_place(ssub, scaledMax, remaining);
380 safe_scaling<RealScalar>::scale_in_place(xj_scaled, scaledMax, remaining);
384 RealScalar onenrm = numext::abs(sdiag[0]) + numext::abs(ssub[0]);
385 onenrm = numext::maxi(onenrm, numext::abs(sdiag[n - 1]) + numext::abs(ssub[n - 2]));
387 onenrm = numext::maxi(onenrm, (ssub.head(n - 2).array().abs() + sdiag.segment(1, n - 2).array().abs() +
388 ssub.segment(1, n - 2).array().abs())
390 if (numext::is_exactly_zero(onenrm)) onenrm = RealScalar(1);
393 const RealScalar ortol = RealScalar(1e-3) * onenrm;
394 const RealScalar dtpcrt = numext::sqrt(RealScalar(0.1) / RealScalar(n));
395 const int maxits = 5;
404 Matrix<Index, Dynamic, 1> clstart(m);
407 RealScalar xjm = RealScalar(0);
408 for (Index j = 0; j < m; ++j) {
409 RealScalar xj = xj_scaled[j];
416 const RealScalar pertol = numext::mini(RealScalar(10) * numext::abs(eps * xj), RealScalar(0.25) * ortol);
417 if (xj - xjm < pertol) xj = xjm + pertol;
419 if (j == 0 || numext::abs(xj - xjm) > ortol) gpind = j;
426 const RealScalar* sdiag_p = sdiag.data();
427 const RealScalar* ssub_p = ssub.data();
428 const RealScalar* xj_p = xj_scaled.data();
429 const Index* cl_p = clstart.data();
437#if defined(EIGEN_HAS_OPENMP)
441 if (omp_get_num_threads() == 1) {
446 const double work = double(m) * double(n);
447 const double kMinTaskSize = 2048.0;
448 const Index work_threads = Index(work / kMinTaskSize);
449 nthreads = int(numext::maxi(Index(1), numext::mini(work_threads, Index(Eigen::nbThreads()))));
452#pragma omp parallel num_threads(nthreads) reduction(+ : nonconv)
454 const Index nt = omp_get_num_threads();
455 const Index tid = omp_get_thread_num();
459 Index lo = tid * m / nt;
460 Index hi = (tid + 1) * m / nt;
461 while (lo < m && cl_p[lo] != lo) ++lo;
462 while (hi < m && cl_p[hi] != hi) ++hi;
463 nonconv += tridiagonal_inverse_iteration_block<RealScalar>(sdiag_p, ssub_p, xj_p, cl_p, n, onenrm, dtpcrt, maxits,
464 extra, eivecs, lo, hi);
469 nonconv = tridiagonal_inverse_iteration_block<RealScalar>(sdiag_p, ssub_p, xj_p, cl_p, n, onenrm, dtpcrt, maxits,
470 extra, eivecs, 0, m);
518template <
typename DiagType,
typename SubdiagType,
typename EivalType,
typename EivecType>
519Index tridiagonal_inverse_iteration(
const DiagType& diag,
const SubdiagType& subdiag,
const EivalType& eivals,
521 typename DiagType::Scalar shift_tol =
typename DiagType::Scalar(0)) {
522 using RealScalar =
typename DiagType::Scalar;
523 using VectorType = Matrix<RealScalar, Dynamic, 1>;
524 const Index n = diag.size();
525 const Index m = eivals.size();
526 if (n == 0 || m == 0)
return 0;
535 RealScalar maxCoeff = safe_scaling<RealScalar>::recover_flushed_max_coeff(diag, diag.cwiseAbs().maxCoeff());
537 maxCoeff = max_preserving_subnormals(
538 maxCoeff, safe_scaling<RealScalar>::recover_flushed_max_coeff(subdiag, subdiag.cwiseAbs().maxCoeff()));
542 const int e = frexp_exponent_preserving_subnormals(maxCoeff);
543 if (e != 0 && e <= safe_scaling<RealScalar>::subnormal_recovery_exponent()) {
544 VectorType sdiag(n), ssub(n - 1), seivals(m), stol(1);
545 const auto factors = safe_scaling<RealScalar>::scale_to(sdiag, diag, maxCoeff);
546 safe_scaling<RealScalar>::scale_to(ssub, subdiag, maxCoeff, factors);
547 safe_scaling<RealScalar>::scale_to(seivals, eivals, maxCoeff, factors);
548 safe_scaling<RealScalar>::scale_to(stol, VectorType::Constant(1, shift_tol), maxCoeff, factors);
549 return tridiagonal_inverse_iteration(sdiag, ssub, seivals, eivecs, stol(0));
558 const RealScalar eps = NumTraits<RealScalar>::epsilon();
559 Matrix<Index, Dynamic, 1> bstart(n + 1);
563 const Array<bool, Dynamic, 1> split = (subdiag.array().abs() <= eps * (diag.head(n - 1).array().abs().sqrt() *
564 diag.tail(n - 1).array().abs().sqrt()));
565 for (Index k = 0; k + 1 < n; ++k)
566 if (split(k)) bstart(nblocks++) = k + 1;
570 if (nblocks == 1)
return tridiagonal_inverse_iteration_connected(diag, subdiag, eivals, eivecs);
578 const RealScalar safemin = numext::maxi(RealScalar(1) / NumTraits<RealScalar>::highest(),
579 (RealScalar(1) + eps) * (std::numeric_limits<RealScalar>::min)());
581 VectorType alpha_all(n), beta_sq_all(n), bscale(nblocks), bpivmin(nblocks), btol(nblocks), bgap(nblocks);
582 RealScalar gscale = RealScalar(0);
583 for (Index b = 0; b < nblocks; ++b) {
584 const Index b0 = bstart(b), nb = bstart(b + 1) - b0;
585 RealScalar s = diag.segment(b0, nb).cwiseAbs().maxCoeff();
586 if (nb > 1) s = numext::maxi(s, subdiag.segment(b0, nb - 1).cwiseAbs().maxCoeff());
587 if (numext::is_exactly_zero(s)) s = RealScalar(1);
588 gscale = numext::maxi(gscale, s);
589 auto alpha = alpha_all.segment(b0, nb);
590 const auto factors = safe_scaling<RealScalar>::scale_to(alpha, diag.segment(b0, nb), s);
591 bscale(b) = factors.scale;
592 RealScalar max_bsq = RealScalar(0);
594 RealScalar onenrm = numext::abs(alpha(0));
596 auto beta = beta_sq_all.segment(b0, nb - 1);
597 safe_scaling<RealScalar>::scale_to(beta, subdiag.segment(b0, nb - 1), s, factors);
598 beta = beta.cwiseAbs();
599 for (Index i = 0; i < nb; ++i) {
600 const RealScalar radius = (i > 0 ? beta(i - 1) : RealScalar(0)) + (i + 1 < nb ? beta(i) : RealScalar(0));
601 onenrm = numext::maxi(onenrm, numext::abs(alpha(i)) + radius);
603 beta = beta.array().square();
604 max_bsq = beta.maxCoeff();
606 bpivmin(b) = safemin * numext::maxi(max_bsq, RealScalar(1));
607 bgap(b) = RealScalar(1e-3) * onenrm * bscale(b);
609 btol(b) = RealScalar(2.1) * (RealScalar(3) * RealScalar(nb) * eps + RealScalar(4) * safemin) * s;
624 const RealScalar gtol = RealScalar(2.1) * (RealScalar(3) * RealScalar(n) * eps + RealScalar(4) * safemin) * gscale;
625 Matrix<Index, Dynamic, 1> blockof(m), assigned(nblocks), caps(nblocks), below_prev(nblocks), below_cur(nblocks),
626 below_edge(nblocks), carry(m), carry_next(m);
628 Matrix<Index, Dynamic, 1> local_index(m);
629 Array<bool, Dynamic, 1> claimed = Array<bool, Dynamic, 1>::Constant(n,
false);
635 const RealScalar highest = NumTraits<RealScalar>::highest();
636 const RealScalar half_ulp_highest =
637 numext::ldexp(RealScalar(1), NumTraits<RealScalar>::max_exponent() - NumTraits<RealScalar>::digits() - 1);
638 auto normalized_shift = [&](Index b, RealScalar x, RealScalar t) -> RealScalar {
639 const RealScalar limit(16);
642 const RealScalar a = numext::maxi(numext::abs(x), numext::abs(t));
643 const RealScalar c = numext::mini(numext::abs(x), numext::abs(t));
644 const bool beyond = (x > RealScalar(0)) == (t > RealScalar(0)) && c - (highest - a) >= half_ulp_highest;
645 const RealScalar y = x + (beyond ? RealScalar(0) : t);
647 const RealScalar ymax = numext::mini(bscale(b), highest / limit) * limit;
648 const RealScalar yn = numext::mini(numext::maxi(y, -ymax), ymax) / bscale(b);
649 return beyond ? (t > RealScalar(0) ? limit : -limit) : yn;
652 auto count_below = [&](Index b, RealScalar x, RealScalar t) -> Index {
653 const Index b0 = bstart(b), nb = bstart(b + 1) - b0;
654 return tridiagonal_sturm_count_below<RealScalar>(alpha_all.data() + b0, beta_sq_all.data() + b0, nb, bpivmin(b),
655 normalized_shift(b, x, t));
657 for (Index b = 0; b < nblocks; ++b) below_prev(b) = count_below(b, eivals[0], -btol(b));
658 below_edge = below_prev;
661 while (g_begin < m) {
662 Index g_end = g_begin + 1;
663 while (g_end < m && !(eivals[g_begin] < eivals[g_end])) ++g_end;
665 const bool first = (g_begin == 0);
666 const bool last = (g_end >= m);
667 const RealScalar mid_bound =
668 last ? RealScalar(0) : RealScalar(0.5) * eivals[g_end - 1] + RealScalar(0.5) * eivals[g_end];
669 bool widened =
false;
672 for (Index b = 0; b < nblocks; ++b) {
675 last ? count_below(b, eivals[m - 1], widened ? gtol : btol(b)) : count_below(b, mid_bound, -RealScalar(0));
676 caps(b) = numext::maxi(Index(0), below_cur(b) - below_prev(b));
681 if (widened || !(first || last) || total >= g_end - g_begin + (last ? ncarry : 0))
break;
684 for (Index b = 0; b < nblocks; ++b) below_prev(b) = count_below(b, eivals[0], -gtol);
685 below_edge = below_prev;
689 Index ncarry_next = 0;
690 for (Index pass = 0; pass < 2; ++pass) {
691 const Index count = (pass == 0) ? g_end - g_begin : ncarry;
692 for (Index c = 0; c < count; ++c) {
693 const Index j = (pass == 0) ? g_begin + c : carry(c);
695 for (Index b = 0; b < nblocks && chosen < 0; ++b)
696 if (caps(b) > 0) chosen = b;
698 carry_next(ncarry_next++) = j;
701 const Index index = below_cur(chosen) - caps(chosen);
702 local_index(j) = index;
703 claimed(bstart(chosen) + index) =
true;
709 carry.swap(carry_next);
710 ncarry = ncarry_next;
711 below_prev = below_cur;
715 for (Index c = 0; c < ncarry; ++c) {
716 const Index j = carry(c);
718 for (Index b = 0; b < nblocks && chosen < 0; ++b)
719 if (below_cur(b) - below_edge(b) - assigned(b) > 0) chosen = b;
721 for (Index b = 0; b < nblocks && chosen < 0; ++b)
722 if (bstart(b + 1) - bstart(b) - assigned(b) > 0) chosen = b;
723 if (chosen < 0) chosen = 0;
725 const Index b0 = bstart(chosen), nb = bstart(chosen + 1) - b0;
726 Index index = numext::mini(below_edge(chosen), nb - 1);
727 while (index < nb && claimed(b0 + index)) ++index;
730 while (index < nb && claimed(b0 + index)) ++index;
736 local_index(j) = index;
737 claimed(b0 + index) =
true;
746 VectorType wloc, refined, endpoints;
747 Matrix<numext::int64_t, Dynamic, 1> counts;
748 Matrix<Index, Dynamic, 1> indices;
749 Matrix<RealScalar, Dynamic, Dynamic> vloc;
750 Matrix<Index, Dynamic, 1> colmap(m);
751 for (Index b = 0; b < nblocks; ++b) {
752 const Index b0 = bstart(b), nb = bstart(b + 1) - b0;
754 for (Index j = 0; j < m; ++j)
755 if (blockof(j) == b) colmap(mb++) = j;
756 if (mb == 0)
continue;
758 for (Index k = 0; k < mb; ++k) wloc(k) = eivals[colmap(k)];
760 const VectorType bdiag = diag.segment(b0, nb);
761 const VectorType bsub = subdiag.segment(b0, nb > 1 ? nb - 1 : 0);
766 for (Index k = 0; k < mb; ++k) indices(k) = local_index(colmap(k));
767 std::sort(indices.data(), indices.data() + mb);
775 bool needs_refinement = shift_tol > bgap(b) * numext::cbrt(RealScalar(32) * eps / numext::sqrt(RealScalar(nb)));
776 if (!needs_refinement) {
777 endpoints.resize(2 * mb);
778 counts.resize(2 * mb);
779 for (Index k = 0; k < mb; ++k) {
780 endpoints(k) = normalized_shift(b, wloc(k), -btol(b));
781 endpoints(mb + k) = normalized_shift(b, wloc(k), btol(b));
783 tridiagonal_sturm_counts(alpha_all.data() + b0, beta_sq_all.data() + b0, nb, bpivmin(b), endpoints.data(),
784 counts.data(), 2 * mb);
787 for (Index k = 0; k < mb && !needs_refinement; ++k) {
788 needs_refinement = counts(k) > indices(k) || counts(mb + k) <= indices(k);
791 if (needs_refinement) {
792 for (Index first = 0; first < mb;) {
793 Index last = first + 1;
794 while (last < mb && indices(last) == indices(last - 1) + 1) ++last;
796 RealScalar(0), refined);
797 wloc.segment(first, last - first) = refined;
802 nonconv += tridiagonal_inverse_iteration_connected(bdiag, bsub, wloc, vloc);
803 for (Index k = 0; k < mb; ++k) eivecs.col(colmap(k)).segment(b0, nb) = vloc.col(k);
842template <
typename DiagType,
typename SubdiagType,
typename EivalType,
typename EivecType>
843void tridiagonal_rayleigh_ritz_refine(
const DiagType& diag,
const SubdiagType& subdiag,
const EivalType& eivals,
845 using RealScalar =
typename DiagType::Scalar;
846 using DenseType = Matrix<RealScalar, Dynamic, Dynamic>;
847 const Index n = diag.size();
848 const Index m = eivals.size();
849 if (n < 2 || m < 2)
return;
852 RealScalar onenrm = numext::abs(diag[0]) + numext::abs(subdiag[0]);
853 onenrm = numext::maxi(onenrm, numext::abs(diag[n - 1]) + numext::abs(subdiag[n - 2]));
854 for (Index i = 1; i < n - 1; ++i)
855 onenrm = numext::maxi(onenrm, numext::abs(subdiag[i - 1]) + numext::abs(diag[i]) + numext::abs(subdiag[i]));
856 const RealScalar ortol = RealScalar(1e-3) * onenrm;
857 if (!(ortol > RealScalar(0)))
return;
858 const RealScalar inv_onenrm = RealScalar(1) / onenrm;
859 const RealScalar refine_threshold = RealScalar(16) * NumTraits<RealScalar>::epsilon();
861 SelfAdjointEigenSolver<DenseType> block_solver;
866 DenseType Vc, TVc, B, Bsym;
870 while (t + 1 < m && (eivals[t + 1] - eivals[t]) < ortol) ++t;
871 const Index c = t - s + 1;
875 Vc = eivecs.middleCols(s, c);
876 TVc = diag.asDiagonal() * Vc;
877 TVc.topRows(n - 1) += subdiag.asDiagonal() * Vc.bottomRows(n - 1);
878 TVc.bottomRows(n - 1) += subdiag.asDiagonal() * Vc.topRows(n - 1);
882 const RealScalar cluster_resid =
883 ((TVc - Vc * eivals.segment(s, c).asDiagonal()) * inv_onenrm).colwise().norm().maxCoeff();
884 if (cluster_resid > refine_threshold) {
885 B.noalias() = Vc.transpose() * TVc;
886 Bsym = B + B.transpose();
887 Bsym *= RealScalar(0.5);
889 eivecs.middleCols(s, c).noalias() = Vc * block_solver.eigenvectors();
@ ComputeEigenvectors
Definition Constants.h:406
static EigenvalueRange indices(Index il, Index iu)
Definition TridiagonalBisection.h:53