sopt::algorithm Namespace Reference

Classes
class	ImagingForwardBackward
class	ImagingProximalADMM
class	ImagingPrimalDual
class	JointMAP
class	L1GProximal
class	L2ForwardBackward
class	ProximalADMM
	Proximal Alternate Direction method of mutltipliers. More...
class	PositiveQuadrant
	Computes according to given algorithm and then projects it to the positive quadrant. More...
class	PowerMethod
	Eigenvalue and eigenvector for eigenvalue with largest magnitude. More...
class	PrimalDual
	Primal Dual Algorithm. More...
class	RealIndicator
class	Reweighted
	L0-approximation algorithm, through reweighting. More...
class	SDMM
	Simultaneous-direction method of the multipliers. More...
class	TFGProximal
class	TVPrimalDual

Functions
template<typename ALGORITHM >
PositiveQuadrant< ALGORITHM >	positive_quadrant (ALGORITHM const &algo)
	Extended algorithm where the solution is projected on the positive quadrant. More...
template<typename T >
std::tuple< t_real, T >	power_method (const sopt::LinearTransform< T > &op, const t_uint niters, const t_real relative_difference, const T &initial_vector)
	Returns the eigenvalue and eigenvector for eigenvalue of the Linear Transform with largest magnitude. More...
template<typename T >
std::tuple< t_real, T, std::shared_ptr< sopt::LinearTransform< T > > >	normalise_operator (const std::shared_ptr< sopt::LinearTransform< T > const > &op, const t_uint &niters, const t_real &relative_difference, const T &initial_vector)
template<typename T >
std::tuple< t_real, T, sopt::LinearTransform< T > >	normalise_operator (const sopt::LinearTransform< T > &op, const t_uint &niters, const t_real &relative_difference, const T &initial_vector)
template<typename ALGORITHM >
Reweighted< ALGORITHM >	reweighted (ALGORITHM const &algo, typename Reweighted< ALGORITHM >::t_SetWeights const &set_weights, typename Reweighted< ALGORITHM >::t_Reweightee const &reweightee)
	Factory function to create an l0-approximation by reweighting an l1 norm. More...
template<typename T >
Eigen::CwiseUnaryOp< const details::ProjectPositiveQuadrant< typename T::Scalar >, const T >	positive_quadrant (Eigen::DenseBase< T > const &input)
template<typename SCALAR >
Reweighted< PositiveQuadrant< ImagingProximalADMM< SCALAR > > >	reweighted (ImagingProximalADMM< SCALAR > const &algo)
template<typename SCALAR >
Reweighted< PositiveQuadrant< PrimalDual< SCALAR > > >	reweighted (PrimalDual< SCALAR > const &algo)

Function Documentation

normalise_operator() [1/2]

template<typename T >

std::tuple<t_real, T, sopt::LinearTransform<T> > sopt::algorithm::normalise_operator	(	const sopt::LinearTransform< T > &	op,
		const t_uint &	niters,
		const t_real &	relative_difference,
		const T &	initial_vector
	)

Definition at line 75 of file power_method.h.

                             {
  const std::shared_ptr<sopt::LinearTransform<T>> shared_op =
      std::make_shared<sopt::LinearTransform<T>>(std::move(op));
  const auto result = normalise_operator<T>(shared_op, niters, relative_difference, initial_vector);
  const auto normed_shared_op = std::get<2>(result);
  return std::make_tuple(std::get<0>(result), std::get<1>(result), *normed_shared_op);
}

normalise_operator() [2/2]

template<typename T >

std::tuple<t_real, T, std::shared_ptr<sopt::LinearTransform<T> > > sopt::algorithm::normalise_operator	(	const std::shared_ptr< sopt::LinearTransform< T > const > &	op,
		const t_uint &	niters,
		const t_real &	relative_difference,
		const T &	initial_vector
	)

Definition at line 59 of file power_method.h.

                                                                {
  const auto result = power_method(*op, niters, relative_difference, initial_vector.derived());
  const t_real norm = std::get<0>(result);
  return std::make_tuple(
      std::get<0>(result), std::get<1>(result),
      std::make_shared<sopt::LinearTransform<T>>(
          [op, norm](T &output, const T &input) { output = static_cast<T>(*op * input) / norm; },
          op->sizes(),
          [op, norm](T &output, const T &input) {
            output = static_cast<T>(op->adjoint() * input) / norm;
          },
          op->adjoint().sizes()));
}

References power_method().

positive_quadrant() [1/2]

template<typename ALGORITHM >

PositiveQuadrant<ALGORITHM> sopt::algorithm::positive_quadrant

(

ALGORITHM const &

algo

)

Extended algorithm where the solution is projected on the positive quadrant.

Definition at line 59 of file positive_quadrant.h.

                                                                     {
  return {algo};
}

Referenced by sopt::algorithm::PositiveQuadrant< ALGORITHM >::operator()(), and reweighted().

positive_quadrant() [2/2]

template<typename T >

Eigen::CwiseUnaryOp< const details::ProjectPositiveQuadrant< typename T::Scalar >, const T > sopt::algorithm::positive_quadrant

(

Eigen::DenseBase< T > const &

input

)

power_method()

template<typename T >

std::tuple<t_real, T> sopt::algorithm::power_method	(	const sopt::LinearTransform< T > &	op,
		const t_uint	niters,
		const t_real	relative_difference,
		const T &	initial_vector
	)

Returns the eigenvalue and eigenvector for eigenvalue of the Linear Transform with largest magnitude.

Definition at line 23 of file power_method.h.

                                                                                              {
  /*
     Attempt at coding the power method, returns the sqrt of the largest eigen value of a linear
     operator composed with its adjoint niters:: max number of iterations relative_difference::
     percentage difference at which eigen value has converged
     */
  if (niters <= 0) return std::make_tuple(1., initial_vector);
  t_real estimate_eigen_value = 1;
  t_real old_value = 0;
  T estimate_eigen_vector = initial_vector;
  estimate_eigen_vector = estimate_eigen_vector / estimate_eigen_vector.matrix().stableNorm();
  SOPT_DEBUG("Starting power method");
  SOPT_DEBUG(" -[PM] Iteration: 0, norm = {}", estimate_eigen_value);
  bool converged = false;
  ScalarRelativeVariation<t_real> scalvar(relative_difference, 0., "Eigenvalue");
  for (t_int i = 0; i < niters; ++i) {
    estimate_eigen_vector = op.adjoint() * static_cast<T>(op * estimate_eigen_vector);
    estimate_eigen_value = estimate_eigen_vector.matrix().stableNorm();
    if (estimate_eigen_value <= 0) throw std::runtime_error("Error in operator.");
    if (estimate_eigen_value != estimate_eigen_value)
      throw std::runtime_error("Error in operator or data corrupted.");
    estimate_eigen_vector = estimate_eigen_vector / estimate_eigen_value;
    SOPT_DEBUG(" -[PM] Iteration: {}, norm = {}", i + 1, estimate_eigen_value);
    converged = scalvar(std::sqrt(estimate_eigen_value));
    old_value = estimate_eigen_value;
    if (converged) {
      SOPT_DEBUG("Converged to norm = {}, relative difference < {}", std::sqrt(old_value),
                 relative_difference);
      break;
    }
  }
  return std::make_tuple(std::sqrt(old_value), estimate_eigen_vector);
}

References sopt::LinearTransform< VECTOR >::adjoint(), and SOPT_DEBUG.

Referenced by normalise_operator().

reweighted() [1/3]

template<typename ALGORITHM >

Reweighted< ALGORITHM > sopt::algorithm::reweighted	(	ALGORITHM const &	algo,
		typename Reweighted< ALGORITHM >::t_SetWeights const &	set_weights,
		typename Reweighted< ALGORITHM >::t_Reweightee const &	reweightee
	)

Factory function to create an l0-approximation by reweighting an l1 norm.

Definition at line 238 of file reweighted.h.

                                                                                               {
  return {algo, set_weights, reweightee};
}

Referenced by main(), and TEST_CASE().

reweighted() [2/3]

template<typename SCALAR >

Reweighted<PositiveQuadrant<ImagingProximalADMM<SCALAR> > > sopt::algorithm::reweighted

(

ImagingProximalADMM< SCALAR > const &

algo

)

Definition at line 253 of file reweighted.h.

                                             {
  auto const posq = positive_quadrant(algo);
  using Algorithm = typename std::remove_const<decltype(posq)>::type;
  using RW = Reweighted<Algorithm>;
  auto const reweightee =
      [](Algorithm const &posq, typename RW::XVector const &x) -> typename RW::XVector {
    return posq.algorithm().Psi().adjoint() * x;
  };
  auto const set_weights = [](Algorithm &posq, typename RW::WeightVector const &weights) -> void {
    posq.algorithm().l1_proximal_weights(weights);
  };
  return {posq, set_weights, reweightee};
}

References sopt::algorithm::Reweighted< ALGORITHM >::algorithm(), and positive_quadrant().

reweighted() [3/3]

template<typename SCALAR >

Reweighted<PositiveQuadrant<PrimalDual<SCALAR> > > sopt::algorithm::reweighted

(

PrimalDual< SCALAR > const &

algo

)

Definition at line 277 of file reweighted.h.

                                                                                            {
  auto const posq = positive_quadrant(algo);
  using Algorithm = typename std::remove_const<decltype(posq)>::type;
  using RW = Reweighted<Algorithm>;
  auto const reweightee =
      [](Algorithm const &posq, typename RW::XVector const &x) -> typename RW::XVector {
    return posq.algorithm().Psi().adjoint() * x;
  };
  auto const set_weights = [](Algorithm &posq, typename RW::WeightVector const &weights) -> void {
    posq.algorithm().l1_proximal_weights(weights);
  };
  return {posq, set_weights, reweightee};
}

References sopt::algorithm::Reweighted< ALGORITHM >::algorithm(), and positive_quadrant().