sopt::algorithm::PowerMethod< SCALAR > Class Template Reference

Eigenvalue and eigenvector for eigenvalue with largest magnitude. More...

#include <power_method.h>

Classes
struct	DiagnosticAndResult
	Holds result vector as well. More...

Public Types
using	value_type = SCALAR
	Scalar type. More...
using	Scalar = value_type
	Scalar type. More...
using	Real = typename real_type< Scalar >::type
	Real type. More...
using	t_Vector = Vector< Scalar >
	Type of then underlying vectors. More...
using	t_LinearTransform = LinearTransform< t_Vector >
	Type of the Ψ and Ψ^H operations, as well as Φ and Φ^H. More...

Public Member Functions
	PowerMethod ()
	Setups ProximalADMM. More...
virtual	~PowerMethod ()
DiagnosticAndResult	AtA (t_LinearTransform const &A, t_Vector const &input) const
	Maximum number of iterations. More...
template<typename DERIVED >
DiagnosticAndResult	operator() (Eigen::DenseBase< DERIVED > const &A, t_Vector const &input) const
	Calls the power method for A, with A a matrix. More...
DiagnosticAndResult	operator() (OperatorFunction< t_Vector > const &op, t_Vector const &input) const
	Calls the power method for a given matrix-vector multiplication function. More...

Detailed Description

template<typename SCALAR>
class sopt::algorithm::PowerMethod< SCALAR >

Eigenvalue and eigenvector for eigenvalue with largest magnitude.

Definition at line 137 of file power_method.h.

Member Typedef Documentation

Real

template<typename SCALAR >

using sopt::algorithm::PowerMethod< SCALAR >::Real = typename real_type<Scalar>::type

Real type.

Definition at line 144 of file power_method.h.

Scalar

template<typename SCALAR >

using sopt::algorithm::PowerMethod< SCALAR >::Scalar = value_type

Scalar type.

Definition at line 142 of file power_method.h.

t_LinearTransform

template<typename SCALAR >

using sopt::algorithm::PowerMethod< SCALAR >::t_LinearTransform = LinearTransform<t_Vector>

Type of the Ψ and Ψ^H operations, as well as Φ and Φ^H.

Definition at line 148 of file power_method.h.

t_Vector

template<typename SCALAR >

using sopt::algorithm::PowerMethod< SCALAR >::t_Vector = Vector<Scalar>

Type of then underlying vectors.

Definition at line 146 of file power_method.h.

value_type

template<typename SCALAR >

using sopt::algorithm::PowerMethod< SCALAR >::value_type = SCALAR

Scalar type.

Definition at line 140 of file power_method.h.

Constructor & Destructor Documentation

PowerMethod()

template<typename SCALAR >

sopt::algorithm::PowerMethod< SCALAR >::PowerMethod ( )

inline

Setups ProximalADMM.

Definition at line 163 of file power_method.h.

: itermax_(std::numeric_limits<t_uint>::max()), tolerance_(1e-8) {}

~PowerMethod()

template<typename SCALAR >

virtual sopt::algorithm::PowerMethod< SCALAR >::~PowerMethod ( )

inlinevirtual

Definition at line 164 of file power_method.h.

{}

Member Function Documentation

AtA()

template<typename SCALAR >

PowerMethod< SCALAR >::DiagnosticAndResult sopt::algorithm::PowerMethod< SCALAR >::AtA	(	t_LinearTransform const &	A,
		t_Vector const &	input
	)		const

Maximum number of iterations.

Convergence criteria

Calls the power method for A.adjoint() * A

Definition at line 199 of file power_method.h.

                                                             {
  auto const op = [&A](t_Vector &out, t_Vector const &input) -> void {
    out = A.adjoint() * static_cast<t_Vector>(A * input);
  };
  return operator()(op, input);
}

References sopt::LinearTransform< VECTOR >::adjoint().

Referenced by main().

operator()() [1/2]

template<typename SCALAR >

template<typename DERIVED >

PowerMethod< SCALAR >::DiagnosticAndResult sopt::algorithm::PowerMethod< SCALAR >::operator()	(	Eigen::DenseBase< DERIVED > const &	A,
		t_Vector const &	input
	)		const

Calls the power method for A, with A a matrix.

Definition at line 209 of file power_method.h.

                                                                   {
  Matrix<Scalar> const Ad = A.derived();
  auto const op = [&Ad](t_Vector &out, t_Vector const &input) -> void { out = Ad * input; };
  return operator()(op, input);
}

operator()() [2/2]

template<typename SCALAR >

PowerMethod< SCALAR >::DiagnosticAndResult sopt::algorithm::PowerMethod< SCALAR >::operator()	(	OperatorFunction< t_Vector > const &	op,
		t_Vector const &	input
	)		const

Calls the power method for a given matrix-vector multiplication function.

Definition at line 217 of file power_method.h.

                                                                       {
  SOPT_INFO("Computing the upper bound of a given operator");
  SOPT_INFO("    - input vector {}", input.transpose());
  t_Vector eigenvector = input.normalized();
  SOPT_INFO("    - eigenvector norm {}", eigenvector.stableNorm());
  typename t_Vector::Scalar previous_magnitude = 1;
  bool converged = false;
  t_uint niters = 0;
 
  for (; niters < itermax() and converged == false; ++niters) {
    op(eigenvector, eigenvector);
    typename t_Vector::Scalar const magnitude =
        eigenvector.stableNorm() / static_cast<Real>(eigenvector.size());
    auto const rel_val = std::abs((magnitude - previous_magnitude) / previous_magnitude);
    converged = rel_val < tolerance();
    SOPT_INFO("    - [PM] iteration {}/{} -- norm: {}", niters, itermax(), magnitude);
 
    eigenvector /= magnitude;
    previous_magnitude = magnitude;
  }
  // check function exists, otherwise, don't know if convergence is meaningful
  if (not converged) {
    SOPT_WARN("    - [PM] did not converge within {} iterations", itermax());
  } else {
    SOPT_INFO("    - [PM] converged in {} of {} iterations", niters, itermax());
  }
  return DiagnosticAndResult{itermax(), converged, previous_magnitude, eigenvector.normalized()};
}

References SOPT_INFO, and SOPT_WARN.

---

The documentation for this class was generated from the following file:

• /home/runner/work/sopt/sopt/cpp/sopt/power_method.h