11 #ifndef EIGEN_JACOBISVD_H 12 #define EIGEN_JACOBISVD_H 19 template<
typename MatrixType,
int QRPreconditioner,
20 bool IsComplex = NumTraits<typename MatrixType::Scalar>::IsComplex>
21 struct svd_precondition_2x2_block_to_be_real {};
30 enum { PreconditionIfMoreColsThanRows, PreconditionIfMoreRowsThanCols };
32 template<
typename MatrixType,
int QRPreconditioner,
int Case>
33 struct qr_preconditioner_should_do_anything
35 enum { a = MatrixType::RowsAtCompileTime !=
Dynamic &&
36 MatrixType::ColsAtCompileTime !=
Dynamic &&
37 MatrixType::ColsAtCompileTime <= MatrixType::RowsAtCompileTime,
38 b = MatrixType::RowsAtCompileTime !=
Dynamic &&
39 MatrixType::ColsAtCompileTime !=
Dynamic &&
40 MatrixType::RowsAtCompileTime <= MatrixType::ColsAtCompileTime,
42 (Case == PreconditionIfMoreColsThanRows &&
bool(a)) ||
43 (Case == PreconditionIfMoreRowsThanCols &&
bool(b)) )
47 template<
typename MatrixType,
int QRPreconditioner,
int Case,
48 bool DoAnything = qr_preconditioner_should_do_anything<MatrixType, QRPreconditioner, Case>::ret
49 >
struct qr_preconditioner_impl {};
51 template<
typename MatrixType,
int QRPreconditioner,
int Case>
52 class qr_preconditioner_impl<MatrixType, QRPreconditioner, Case, false>
55 void allocate(
const JacobiSVD<MatrixType, QRPreconditioner>&) {}
56 bool run(JacobiSVD<MatrixType, QRPreconditioner>&,
const MatrixType&)
64 template<
typename MatrixType>
68 typedef typename MatrixType::Scalar Scalar;
71 RowsAtCompileTime = MatrixType::RowsAtCompileTime,
72 MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime
74 typedef Matrix<Scalar, 1, RowsAtCompileTime, RowMajor, 1, MaxRowsAtCompileTime> WorkspaceType;
76 void allocate(
const JacobiSVD<MatrixType, FullPivHouseholderQRPreconditioner>& svd)
78 if (svd.rows() != m_qr.rows() || svd.cols() != m_qr.cols())
81 ::new (&m_qr) QRType(svd.rows(), svd.cols());
83 if (svd.m_computeFullU) m_workspace.resize(svd.rows());
86 bool run(JacobiSVD<MatrixType, FullPivHouseholderQRPreconditioner>& svd,
const MatrixType& matrix)
88 if(matrix.rows() > matrix.cols())
91 svd.m_workMatrix = m_qr.matrixQR().block(0,0,matrix.cols(),matrix.cols()).
template triangularView<Upper>();
92 if(svd.m_computeFullU) m_qr.matrixQ().evalTo(svd.m_matrixU, m_workspace);
93 if(svd.computeV()) svd.m_matrixV = m_qr.colsPermutation();
99 typedef FullPivHouseholderQR<MatrixType> QRType;
101 WorkspaceType m_workspace;
104 template<
typename MatrixType>
108 typedef typename MatrixType::Scalar Scalar;
111 RowsAtCompileTime = MatrixType::RowsAtCompileTime,
112 ColsAtCompileTime = MatrixType::ColsAtCompileTime,
113 MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
114 MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
115 TrOptions = RowsAtCompileTime==1 ? (MatrixType::Options & ~(
RowMajor))
116 : ColsAtCompileTime==1 ? (MatrixType::Options |
RowMajor)
117 : MatrixType::Options
119 typedef Matrix<Scalar, ColsAtCompileTime, RowsAtCompileTime, TrOptions, MaxColsAtCompileTime, MaxRowsAtCompileTime>
120 TransposeTypeWithSameStorageOrder;
122 void allocate(
const JacobiSVD<MatrixType, FullPivHouseholderQRPreconditioner>& svd)
124 if (svd.cols() != m_qr.rows() || svd.rows() != m_qr.cols())
127 ::new (&m_qr) QRType(svd.cols(), svd.rows());
129 m_adjoint.resize(svd.cols(), svd.rows());
130 if (svd.m_computeFullV) m_workspace.resize(svd.cols());
133 bool run(JacobiSVD<MatrixType, FullPivHouseholderQRPreconditioner>& svd,
const MatrixType& matrix)
135 if(matrix.cols() > matrix.rows())
137 m_adjoint = matrix.adjoint();
138 m_qr.compute(m_adjoint);
139 svd.m_workMatrix = m_qr.matrixQR().block(0,0,matrix.rows(),matrix.rows()).
template triangularView<Upper>().adjoint();
140 if(svd.m_computeFullV) m_qr.matrixQ().evalTo(svd.m_matrixV, m_workspace);
141 if(svd.computeU()) svd.m_matrixU = m_qr.colsPermutation();
147 typedef FullPivHouseholderQR<TransposeTypeWithSameStorageOrder> QRType;
149 TransposeTypeWithSameStorageOrder m_adjoint;
150 typename internal::plain_row_type<MatrixType>::type m_workspace;
155 template<
typename MatrixType>
159 void allocate(
const JacobiSVD<MatrixType, ColPivHouseholderQRPreconditioner>& svd)
161 if (svd.rows() != m_qr.rows() || svd.cols() != m_qr.cols())
164 ::new (&m_qr) QRType(svd.rows(), svd.cols());
166 if (svd.m_computeFullU) m_workspace.resize(svd.rows());
167 else if (svd.m_computeThinU) m_workspace.resize(svd.cols());
170 bool run(JacobiSVD<MatrixType, ColPivHouseholderQRPreconditioner>& svd,
const MatrixType& matrix)
172 if(matrix.rows() > matrix.cols())
174 m_qr.compute(matrix);
175 svd.m_workMatrix = m_qr.matrixQR().block(0,0,matrix.cols(),matrix.cols()).
template triangularView<Upper>();
176 if(svd.m_computeFullU) m_qr.householderQ().evalTo(svd.m_matrixU, m_workspace);
177 else if(svd.m_computeThinU)
179 svd.m_matrixU.setIdentity(matrix.rows(), matrix.cols());
180 m_qr.householderQ().applyThisOnTheLeft(svd.m_matrixU, m_workspace);
182 if(svd.computeV()) svd.m_matrixV = m_qr.colsPermutation();
189 typedef ColPivHouseholderQR<MatrixType> QRType;
191 typename internal::plain_col_type<MatrixType>::type m_workspace;
194 template<
typename MatrixType>
198 typedef typename MatrixType::Scalar Scalar;
201 RowsAtCompileTime = MatrixType::RowsAtCompileTime,
202 ColsAtCompileTime = MatrixType::ColsAtCompileTime,
203 MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
204 MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
205 TrOptions = RowsAtCompileTime==1 ? (MatrixType::Options & ~(
RowMajor))
206 : ColsAtCompileTime==1 ? (MatrixType::Options |
RowMajor)
207 : MatrixType::Options
210 typedef Matrix<Scalar, ColsAtCompileTime, RowsAtCompileTime, TrOptions, MaxColsAtCompileTime, MaxRowsAtCompileTime>
211 TransposeTypeWithSameStorageOrder;
213 void allocate(
const JacobiSVD<MatrixType, ColPivHouseholderQRPreconditioner>& svd)
215 if (svd.cols() != m_qr.rows() || svd.rows() != m_qr.cols())
218 ::new (&m_qr) QRType(svd.cols(), svd.rows());
220 if (svd.m_computeFullV) m_workspace.resize(svd.cols());
221 else if (svd.m_computeThinV) m_workspace.resize(svd.rows());
222 m_adjoint.resize(svd.cols(), svd.rows());
225 bool run(JacobiSVD<MatrixType, ColPivHouseholderQRPreconditioner>& svd,
const MatrixType& matrix)
227 if(matrix.cols() > matrix.rows())
229 m_adjoint = matrix.adjoint();
230 m_qr.compute(m_adjoint);
232 svd.m_workMatrix = m_qr.matrixQR().block(0,0,matrix.rows(),matrix.rows()).
template triangularView<Upper>().adjoint();
233 if(svd.m_computeFullV) m_qr.householderQ().evalTo(svd.m_matrixV, m_workspace);
234 else if(svd.m_computeThinV)
236 svd.m_matrixV.setIdentity(matrix.cols(), matrix.rows());
237 m_qr.householderQ().applyThisOnTheLeft(svd.m_matrixV, m_workspace);
239 if(svd.computeU()) svd.m_matrixU = m_qr.colsPermutation();
246 typedef ColPivHouseholderQR<TransposeTypeWithSameStorageOrder> QRType;
248 TransposeTypeWithSameStorageOrder m_adjoint;
249 typename internal::plain_row_type<MatrixType>::type m_workspace;
254 template<
typename MatrixType>
258 void allocate(
const JacobiSVD<MatrixType, HouseholderQRPreconditioner>& svd)
260 if (svd.rows() != m_qr.rows() || svd.cols() != m_qr.cols())
263 ::new (&m_qr) QRType(svd.rows(), svd.cols());
265 if (svd.m_computeFullU) m_workspace.resize(svd.rows());
266 else if (svd.m_computeThinU) m_workspace.resize(svd.cols());
269 bool run(JacobiSVD<MatrixType, HouseholderQRPreconditioner>& svd,
const MatrixType& matrix)
271 if(matrix.rows() > matrix.cols())
273 m_qr.compute(matrix);
274 svd.m_workMatrix = m_qr.matrixQR().block(0,0,matrix.cols(),matrix.cols()).
template triangularView<Upper>();
275 if(svd.m_computeFullU) m_qr.householderQ().evalTo(svd.m_matrixU, m_workspace);
276 else if(svd.m_computeThinU)
278 svd.m_matrixU.setIdentity(matrix.rows(), matrix.cols());
279 m_qr.householderQ().applyThisOnTheLeft(svd.m_matrixU, m_workspace);
281 if(svd.computeV()) svd.m_matrixV.setIdentity(matrix.cols(), matrix.cols());
287 typedef HouseholderQR<MatrixType> QRType;
289 typename internal::plain_col_type<MatrixType>::type m_workspace;
292 template<
typename MatrixType>
296 typedef typename MatrixType::Scalar Scalar;
299 RowsAtCompileTime = MatrixType::RowsAtCompileTime,
300 ColsAtCompileTime = MatrixType::ColsAtCompileTime,
301 MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
302 MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
303 Options = MatrixType::Options
306 typedef Matrix<Scalar, ColsAtCompileTime, RowsAtCompileTime, Options, MaxColsAtCompileTime, MaxRowsAtCompileTime>
307 TransposeTypeWithSameStorageOrder;
309 void allocate(
const JacobiSVD<MatrixType, HouseholderQRPreconditioner>& svd)
311 if (svd.cols() != m_qr.rows() || svd.rows() != m_qr.cols())
314 ::new (&m_qr) QRType(svd.cols(), svd.rows());
316 if (svd.m_computeFullV) m_workspace.resize(svd.cols());
317 else if (svd.m_computeThinV) m_workspace.resize(svd.rows());
318 m_adjoint.resize(svd.cols(), svd.rows());
321 bool run(JacobiSVD<MatrixType, HouseholderQRPreconditioner>& svd,
const MatrixType& matrix)
323 if(matrix.cols() > matrix.rows())
325 m_adjoint = matrix.adjoint();
326 m_qr.compute(m_adjoint);
328 svd.m_workMatrix = m_qr.matrixQR().block(0,0,matrix.rows(),matrix.rows()).
template triangularView<Upper>().adjoint();
329 if(svd.m_computeFullV) m_qr.householderQ().evalTo(svd.m_matrixV, m_workspace);
330 else if(svd.m_computeThinV)
332 svd.m_matrixV.setIdentity(matrix.cols(), matrix.rows());
333 m_qr.householderQ().applyThisOnTheLeft(svd.m_matrixV, m_workspace);
335 if(svd.computeU()) svd.m_matrixU.setIdentity(matrix.rows(), matrix.rows());
342 typedef HouseholderQR<TransposeTypeWithSameStorageOrder> QRType;
344 TransposeTypeWithSameStorageOrder m_adjoint;
345 typename internal::plain_row_type<MatrixType>::type m_workspace;
353 template<
typename MatrixType,
int QRPreconditioner>
354 struct svd_precondition_2x2_block_to_be_real<MatrixType, QRPreconditioner, false>
356 typedef JacobiSVD<MatrixType, QRPreconditioner> SVD;
357 typedef typename MatrixType::RealScalar RealScalar;
358 static bool run(
typename SVD::WorkMatrixType&, SVD&,
Index,
Index, RealScalar&) {
return true; }
361 template<
typename MatrixType,
int QRPreconditioner>
362 struct svd_precondition_2x2_block_to_be_real<MatrixType, QRPreconditioner, true>
364 typedef JacobiSVD<MatrixType, QRPreconditioner> SVD;
365 typedef typename MatrixType::Scalar Scalar;
366 typedef typename MatrixType::RealScalar RealScalar;
367 static bool run(
typename SVD::WorkMatrixType& work_matrix, SVD& svd,
Index p,
Index q, RealScalar& maxDiagEntry)
372 JacobiRotation<Scalar> rot;
373 RealScalar n =
sqrt(numext::abs2(work_matrix.coeff(p,p)) + numext::abs2(work_matrix.coeff(q,p)));
375 const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
376 const RealScalar precision = NumTraits<Scalar>::epsilon();
381 work_matrix.coeffRef(p,p) = work_matrix.coeffRef(q,p) = Scalar(0);
383 if(
abs(numext::imag(work_matrix.coeff(p,q)))>considerAsZero)
386 z =
abs(work_matrix.coeff(p,q)) / work_matrix.coeff(p,q);
387 work_matrix.row(p) *= z;
388 if(svd.computeU()) svd.m_matrixU.col(p) *=
conj(z);
390 if(
abs(numext::imag(work_matrix.coeff(q,q)))>considerAsZero)
392 z =
abs(work_matrix.coeff(q,q)) / work_matrix.coeff(q,q);
393 work_matrix.row(q) *= z;
394 if(svd.computeU()) svd.m_matrixU.col(q) *=
conj(z);
400 rot.c() =
conj(work_matrix.coeff(p,p)) / n;
401 rot.s() = work_matrix.coeff(q,p) / n;
402 work_matrix.applyOnTheLeft(p,q,rot);
403 if(svd.computeU()) svd.m_matrixU.applyOnTheRight(p,q,rot.adjoint());
404 if(
abs(numext::imag(work_matrix.coeff(p,q)))>considerAsZero)
406 z =
abs(work_matrix.coeff(p,q)) / work_matrix.coeff(p,q);
407 work_matrix.col(q) *= z;
408 if(svd.computeV()) svd.m_matrixV.col(q) *= z;
410 if(
abs(numext::imag(work_matrix.coeff(q,q)))>considerAsZero)
412 z =
abs(work_matrix.coeff(q,q)) / work_matrix.coeff(q,q);
413 work_matrix.row(q) *= z;
414 if(svd.computeU()) svd.m_matrixU.col(q) *=
conj(z);
419 maxDiagEntry = numext::maxi<RealScalar>(maxDiagEntry,numext::maxi<RealScalar>(
abs(work_matrix.coeff(p,p)),
abs(work_matrix.coeff(q,q))));
421 RealScalar threshold = numext::maxi<RealScalar>(considerAsZero, precision * maxDiagEntry);
422 return abs(work_matrix.coeff(p,q))>threshold ||
abs(work_matrix.coeff(q,p)) > threshold;
426 template<
typename _MatrixType,
int QRPreconditioner>
427 struct traits<JacobiSVD<_MatrixType,QRPreconditioner> >
429 typedef _MatrixType MatrixType;
487 template<
typename _MatrixType,
int QRPreconditioner>
class JacobiSVD
488 :
public SVDBase<JacobiSVD<_MatrixType,QRPreconditioner> >
490 typedef SVDBase<JacobiSVD> Base;
493 typedef _MatrixType MatrixType;
494 typedef typename MatrixType::Scalar Scalar;
495 typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
497 RowsAtCompileTime = MatrixType::RowsAtCompileTime,
498 ColsAtCompileTime = MatrixType::ColsAtCompileTime,
499 DiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime,ColsAtCompileTime),
500 MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
501 MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
502 MaxDiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(MaxRowsAtCompileTime,MaxColsAtCompileTime),
503 MatrixOptions = MatrixType::Options
506 typedef typename Base::MatrixUType MatrixUType;
507 typedef typename Base::MatrixVType MatrixVType;
508 typedef typename Base::SingularValuesType SingularValuesType;
510 typedef typename internal::plain_row_type<MatrixType>::type RowType;
511 typedef typename internal::plain_col_type<MatrixType>::type ColType;
512 typedef Matrix<Scalar, DiagSizeAtCompileTime, DiagSizeAtCompileTime,
513 MatrixOptions, MaxDiagSizeAtCompileTime, MaxDiagSizeAtCompileTime>
533 allocate(rows, cols, computationOptions);
546 explicit JacobiSVD(
const MatrixType& matrix,
unsigned int computationOptions = 0)
548 compute(matrix, computationOptions);
561 JacobiSVD& compute(
const MatrixType& matrix,
unsigned int computationOptions);
571 return compute(matrix, m_computationOptions);
574 using Base::computeU;
575 using Base::computeV;
581 void allocate(
Index rows,
Index cols,
unsigned int computationOptions);
584 using Base::m_matrixU;
585 using Base::m_matrixV;
586 using Base::m_singularValues;
587 using Base::m_isInitialized;
588 using Base::m_isAllocated;
589 using Base::m_usePrescribedThreshold;
590 using Base::m_computeFullU;
591 using Base::m_computeThinU;
592 using Base::m_computeFullV;
593 using Base::m_computeThinV;
594 using Base::m_computationOptions;
595 using Base::m_nonzeroSingularValues;
598 using Base::m_diagSize;
599 using Base::m_prescribedThreshold;
600 WorkMatrixType m_workMatrix;
602 template<
typename __MatrixType,
int _QRPreconditioner,
bool _IsComplex>
603 friend struct internal::svd_precondition_2x2_block_to_be_real;
604 template<
typename __MatrixType,
int _QRPreconditioner,
int _Case,
bool _DoAnything>
605 friend struct internal::qr_preconditioner_impl;
607 internal::qr_preconditioner_impl<MatrixType, QRPreconditioner, internal::PreconditionIfMoreColsThanRows> m_qr_precond_morecols;
608 internal::qr_preconditioner_impl<MatrixType, QRPreconditioner, internal::PreconditionIfMoreRowsThanCols> m_qr_precond_morerows;
609 MatrixType m_scaledMatrix;
612 template<
typename MatrixType,
int QRPreconditioner>
615 eigen_assert(rows >= 0 && cols >= 0);
620 computationOptions == m_computationOptions)
627 m_isInitialized =
false;
628 m_isAllocated =
true;
629 m_computationOptions = computationOptions;
630 m_computeFullU = (computationOptions &
ComputeFullU) != 0;
631 m_computeThinU = (computationOptions &
ComputeThinU) != 0;
632 m_computeFullV = (computationOptions &
ComputeFullV) != 0;
633 m_computeThinV = (computationOptions &
ComputeThinV) != 0;
634 eigen_assert(!(m_computeFullU && m_computeThinU) &&
"JacobiSVD: you can't ask for both full and thin U");
635 eigen_assert(!(m_computeFullV && m_computeThinV) &&
"JacobiSVD: you can't ask for both full and thin V");
636 eigen_assert(EIGEN_IMPLIES(m_computeThinU || m_computeThinV, MatrixType::ColsAtCompileTime==
Dynamic) &&
637 "JacobiSVD: thin U and V are only available when your matrix has a dynamic number of columns.");
640 eigen_assert(!(m_computeThinU || m_computeThinV) &&
641 "JacobiSVD: can't compute thin U or thin V with the FullPivHouseholderQR preconditioner. " 642 "Use the ColPivHouseholderQR preconditioner instead.");
644 m_diagSize = (std::min)(m_rows, m_cols);
645 m_singularValues.resize(m_diagSize);
647 m_matrixU.resize(m_rows, m_computeFullU ? m_rows
648 : m_computeThinU ? m_diagSize
651 m_matrixV.resize(m_cols, m_computeFullV ? m_cols
652 : m_computeThinV ? m_diagSize
654 m_workMatrix.resize(m_diagSize, m_diagSize);
656 if(m_cols>m_rows) m_qr_precond_morecols.allocate(*
this);
657 if(m_rows>m_cols) m_qr_precond_morerows.allocate(*
this);
658 if(m_rows!=m_cols) m_scaledMatrix.resize(rows,cols);
661 template<
typename MatrixType,
int QRPreconditioner>
666 allocate(matrix.rows(), matrix.cols(), computationOptions);
673 const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
676 RealScalar scale = matrix.cwiseAbs().maxCoeff();
677 if(scale==RealScalar(0)) scale = RealScalar(1);
683 m_scaledMatrix = matrix / scale;
684 m_qr_precond_morecols.run(*
this, m_scaledMatrix);
685 m_qr_precond_morerows.run(*
this, m_scaledMatrix);
689 m_workMatrix = matrix.block(0,0,m_diagSize,m_diagSize) / scale;
690 if(m_computeFullU) m_matrixU.setIdentity(m_rows,m_rows);
691 if(m_computeThinU) m_matrixU.setIdentity(m_rows,m_diagSize);
692 if(m_computeFullV) m_matrixV.setIdentity(m_cols,m_cols);
693 if(m_computeThinV) m_matrixV.setIdentity(m_cols, m_diagSize);
697 RealScalar maxDiagEntry = m_workMatrix.cwiseAbs().diagonal().maxCoeff();
699 bool finished =
false;
706 for(
Index p = 1; p < m_diagSize; ++p)
708 for(
Index q = 0; q < p; ++q)
713 RealScalar threshold = numext::maxi<RealScalar>(considerAsZero, precision * maxDiagEntry);
714 if(
abs(m_workMatrix.coeff(p,q))>threshold ||
abs(m_workMatrix.coeff(q,p)) > threshold)
719 if(internal::svd_precondition_2x2_block_to_be_real<MatrixType, QRPreconditioner>::run(m_workMatrix, *
this, p, q, maxDiagEntry))
722 internal::real_2x2_jacobi_svd(m_workMatrix, p, q, &j_left, &j_right);
725 m_workMatrix.applyOnTheLeft(p,q,j_left);
726 if(computeU()) m_matrixU.applyOnTheRight(p,q,j_left.
transpose());
728 m_workMatrix.applyOnTheRight(p,q,j_right);
729 if(computeV()) m_matrixV.applyOnTheRight(p,q,j_right);
732 maxDiagEntry = numext::maxi<RealScalar>(maxDiagEntry,numext::maxi<RealScalar>(
abs(m_workMatrix.coeff(p,p)),
abs(m_workMatrix.coeff(q,q))));
741 for(
Index i = 0; i < m_diagSize; ++i)
748 RealScalar a =
abs(m_workMatrix.coeff(i,i));
749 m_singularValues.coeffRef(i) =
abs(a);
750 if(computeU()) m_matrixU.col(i) *= m_workMatrix.coeff(i,i)/a;
755 RealScalar a = numext::real(m_workMatrix.coeff(i,i));
756 m_singularValues.coeffRef(i) =
abs(a);
757 if(computeU() && (a<RealScalar(0))) m_matrixU.col(i) = -m_matrixU.col(i);
761 m_singularValues *= scale;
765 m_nonzeroSingularValues = m_diagSize;
766 for(
Index i = 0; i < m_diagSize; i++)
769 RealScalar maxRemainingSingularValue = m_singularValues.tail(m_diagSize-i).maxCoeff(&pos);
770 if(maxRemainingSingularValue == RealScalar(0))
772 m_nonzeroSingularValues = i;
778 std::swap(m_singularValues.coeffRef(i), m_singularValues.coeffRef(pos));
779 if(computeU()) m_matrixU.col(pos).swap(m_matrixU.col(i));
780 if(computeV()) m_matrixV.col(pos).swap(m_matrixV.col(i));
784 m_isInitialized =
true;
795 template<
typename Derived>
804 #endif // EIGEN_JACOBISVD_H Definition: Constants.h:383
Definition: Constants.h:415
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_sqrt_op< typename Derived::Scalar >, const Derived > sqrt(const Eigen::ArrayBase< Derived > &x)
Definition: Constants.h:389
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_conjugate_op< typename Derived::Scalar >, const Derived > conj(const Eigen::ArrayBase< Derived > &x)
Namespace containing all symbols from the Eigen library.
Definition: Core:287
Rotation given by a cosine-sine pair.
Definition: ForwardDeclarations.h:263
Holds information about the various numeric (i.e. scalar) types allowed by Eigen. ...
Definition: NumTraits.h:150
Definition: Constants.h:417
Definition: Constants.h:419
JacobiSVD< PlainObject > jacobiSvd(unsigned int computationOptions=0) const
Definition: JacobiSVD.h:797
JacobiSVD()
Default Constructor.
Definition: JacobiSVD.h:521
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:33
Definition: Constants.h:421
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_abs_op< typename Derived::Scalar >, const Derived > abs(const Eigen::ArrayBase< Derived > &x)
Definition: Eigen_Colamd.h:50
JacobiSVD & compute(const MatrixType &matrix)
Method performing the decomposition of given matrix using current options.
Definition: JacobiSVD.h:569
Definition: Constants.h:322
Two-sided Jacobi SVD decomposition of a rectangular matrix.
Definition: ForwardDeclarations.h:258
JacobiRotation transpose() const
Definition: Jacobi.h:59
JacobiSVD & compute(const MatrixType &matrix, unsigned int computationOptions)
Method performing the decomposition of given matrix using custom options.
Definition: JacobiSVD.h:663
const int Dynamic
Definition: Constants.h:21
Definition: Constants.h:387
Definition: Constants.h:385
JacobiSVD(Index rows, Index cols, unsigned int computationOptions=0)
Default Constructor with memory preallocation.
Definition: JacobiSVD.h:531
JacobiSVD(const MatrixType &matrix, unsigned int computationOptions=0)
Constructor performing the decomposition of given matrix.
Definition: JacobiSVD.h:546