Namespaces
	algorithm

	cppflowutils

	credible_region

	details

	gradient_operator

	logging

	mpi

	objective_functions

	proximal
	Holds some standard proximals.

	tools

	utilities

	wavelets

Classes
class	ConjugateGradient
	Solves $Ax = b$ for $x$, given $A$ and $b$. More...

class	Exception
	Root exception for sopt. More...

class	IterationState

class	L2DifferentiableFunc

class	LinearTransform
	Joins together direct and indirect operators. More...

class	ONNXDifferentiableFunc

class	ORTsession
	Sopt interface class to hold a ONNXrt session. More...

struct	is_complex
	True if underlying type is complex. More...

struct	is_complex< std::complex< T >, void >
	True if underlying type is complex. More...

class	RelativeVariation

class	ScalarRelativeVariation

class	Sampling
	An operator that samples a set of measurements. More...

struct	CData

Typedefs
template<typename T >
using	real_type = details::underlying_value_type< T >
	Gets to the underlying real type. More...

using	t_int = int
	Root of the type hierarchy for signed integers. More...

using	t_uint = size_t
	Root of the type hierarchy for unsigned integers. More...

using	t_real = double
	Root of the type hierarchy for real numbers. More...

using	t_complex = std::complex< t_real >
	Root of the type hierarchy for (real) complex numbers. More...

template<typename T = t_real>
using	Vector = Eigen::Matrix< T, Eigen::Dynamic, 1 >
	A vector of a given type. More...

template<typename T = t_real>
using	Matrix = Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >
	A matrix of a given type. More...

template<typename T = t_real>
using	Array = Eigen::Array< T, Eigen::Dynamic, 1 >
	A 1-dimensional list of elements of given type. More...

template<typename T = t_real>
using	Image = Eigen::Array< T, Eigen::Dynamic, Eigen::Dynamic >
	A 2-dimensional list of elements of given type. More...

template<typename VECTOR = Vector<>>
using	OperatorFunction = std::function< void(VECTOR &, VECTOR const &)>
	Typical function out = A*x. More...

template<typename SCALAR = t_real>
using	ProximalFunction = std::function< void(Vector< SCALAR > &output, typename real_type< SCALAR >::type const weight, Vector< SCALAR > const &input)>
	Typical function signature for calls to proximal. More...

template<typename SCALAR = t_real>
using	ConvergenceFunction = std::function< bool(Vector< SCALAR > const &)>
	Typical function signature for convergence. More...

Functions
template<typename K >
std::enable_if< std::is_same< t_real, K >::value, K >::type	bisection_method (const K &function_value, const std::function< K(K)> &func, const K &a, const K &b, const t_real &rel_convergence=1e-4)
	Find root to a function within an interval. More...

template<typename T0 , typename... T>
OperatorFunction< T0 >	chained_operators (OperatorFunction< T0 > const &arg0, T const &... args)

std::string	version ()
	Returns library version. More...

std::tuple< uint8_t, uint8_t, uint8_t >	version_tuple ()
	Returns library version. More...

std::string	gitref ()
	Returns library git reference, if known. More...

std::string	default_logging_level ()
	Default logging level. More...

std::string	default_logger_name ()
	Default logger name. More...

constexpr std::size_t	number_of_threads_in_tests ()
	Number of threads used during testing. More...

template<typename VECTOR >
LinearTransform< VECTOR >	linear_transform (OperatorFunction< VECTOR > const &direct, OperatorFunction< VECTOR > const &indirect, std::array< t_int, 3 > const &sizes={{1, 1, 0}})

template<typename VECTOR >
LinearTransform< VECTOR >	linear_transform (OperatorFunction< VECTOR > const &direct, std::array< t_int, 3 > const &dsizes, OperatorFunction< VECTOR > const &indirect, std::array< t_int, 3 > const &isizes)

template<typename VECTOR >
LinearTransform< VECTOR > &	linear_transform (LinearTransform< VECTOR > &passthrough)
	Convenience no-op function. More...

template<typename VECTOR >
LinearTransform< VECTOR >	linear_transform (details::WrapFunction< VECTOR > const &direct, details::WrapFunction< VECTOR > const &adjoint)
	Creates a linear transform from a pair of wrappers. More...

template<typename DERIVED >
LinearTransform< Vector< typename DERIVED::Scalar > >	linear_transform (Eigen::MatrixBase< DERIVED > const &A)
	Helper function to creates a function operator. More...

template<typename SCALAR >
LinearTransform< Vector< SCALAR > >	linear_transform_identity ()
	Helper function to create a linear transform that's just the identity. More...

template<typename T >
real_type< typename T::Scalar >::type	standard_deviation (Eigen::ArrayBase< T > const &x)
	Computes the standard deviation of a vector. More...

template<typename T >
real_type< typename T::Scalar >::type	standard_deviation (Eigen::MatrixBase< T > const &x)
	Computes the standard deviation of a vector. More...

template<typename SCALAR >
std::enable_if< std::is_arithmetic< SCALAR >::value or is_complex< SCALAR >::value, SCALAR >::type	soft_threshhold (SCALAR const &x, typename real_type< SCALAR >::type const &threshhold)
	abs(x) < threshhold ? 0: x - sgn(x) * threshhold More...

template<typename T >
Eigen::CwiseUnaryOp< const details::ProjectPositiveQuadrant< typename T::Scalar >, const T >	positive_quadrant (Eigen::DenseBase< T > const &input)
	Expression to create projection onto positive quadrant. More...

template<typename T >
Eigen::CwiseUnaryOp< const details::SoftThreshhold< typename T::Scalar >, const T >	soft_threshhold (Eigen::DenseBase< T > const &input, typename real_type< typename T::Scalar >::type const &threshhold)
	Expression to create soft-threshhold. More...

template<typename T0 , typename T1 >
std::enable_if< std::is_arithmetic< typename T0::Scalar >::value and std::is_arithmetic< typename T1::Scalar >::value, Eigen::CwiseBinaryOp< typename T0::Scalar(*)(typename T0::Scalar const &, typename T1::Scalar const &), const T0, const T1 > >::type	soft_threshhold (Eigen::DenseBase< T0 > const &input, Eigen::DenseBase< T1 > const &threshhold)
	Expression to create soft-threshhold with multiple parameters. More...

template<typename T0 , typename T1 >
std::enable_if< is_complex< typename T0::Scalar >::value and std::is_arithmetic< typename T1::Scalar >::value, Eigen::CwiseBinaryOp< typename T0::Scalar(*)(typename T0::Scalar const &, typename T0::Scalar const &), const T0, decltype(std::declval< const T1 >).template cast< typename T0::Scalar >))> >::type	soft_threshhold (Eigen::DenseBase< T0 > const &input, Eigen::DenseBase< T1 > const &threshhold)
	Expression to create soft-threshhold with multiple parameters. More...

template<typename T0 , typename T1 >
real_type< typename T0::Scalar >::type	l1_norm (Eigen::ArrayBase< T0 > const &input, Eigen::ArrayBase< T1 > const &weights)
	Computes weighted L1 norm. More...

template<typename T0 , typename T1 >
real_type< typename T0::Scalar >::type	l1_norm (Eigen::MatrixBase< T0 > const &input, Eigen::MatrixBase< T1 > const &weight)
	Computes weighted L1 norm. More...

template<typename T0 >
real_type< typename T0::Scalar >::type	l1_norm (Eigen::ArrayBase< T0 > const &input)
	Computes L1 norm. More...

template<typename T0 >
real_type< typename T0::Scalar >::type	l1_norm (Eigen::MatrixBase< T0 > const &input)
	Computes L1 norm. More...

template<typename T0 , typename T1 >
real_type< typename T0::Scalar >::type	l2_norm (Eigen::ArrayBase< T0 > const &input, Eigen::ArrayBase< T1 > const &weights)
	Computes weighted L2 norm. More...

template<typename T0 , typename T1 >
real_type< typename T0::Scalar >::type	l2_norm (Eigen::MatrixBase< T0 > const &input, Eigen::MatrixBase< T1 > const &weights)
	Computes weighted L2 norm. More...

template<typename T0 >
real_type< typename T0::Scalar >::type	l2_norm (Eigen::ArrayBase< T0 > const &input)
	Computes weighted L2 norm. More...

template<typename T0 >
real_type< typename T0::Scalar >::type	l2_norm (Eigen::MatrixBase< T0 > const &input)
	Computes weighted L2 norm. More...

template<typename T0 , typename T1 >
real_type< typename T0::Scalar >::type	tv_norm (Eigen::ArrayBase< T0 > const &input, Eigen::ArrayBase< T1 > const &weights)
	Computes weighted TV norm. More...

template<typename T0 , typename T1 >
real_type< typename T0::Scalar >::type	tv_norm (Eigen::MatrixBase< T0 > const &input, Eigen::MatrixBase< T1 > const &weights)
	Computes weighted TV norm. More...

template<typename T0 >
real_type< typename T0::Scalar >::type	tv_norm (Eigen::ArrayBase< T0 > const &input)
	Computes weighted tv norm. More...

template<typename T0 >
real_type< typename T0::Scalar >::type	tv_norm (Eigen::MatrixBase< T0 > const &input)
	Computes weighted TV norm. More...

template<typename T >
LinearTransform< Vector< T > >	linear_transform (Sampling const &sampling)
	Returns linear transform version of this object. More...

template<typename T >
LinearTransform< Vector< T > >	linear_transform (wavelets::Wavelet const &wavelet)
	Thin linear-transform wrapper around 1d wavelets. More...

template<typename T >
LinearTransform< Vector< T > >	linear_transform (wavelets::SARA const &sara)
	Thin linear-transform wrapper around 1d sara operator. More...

template<typename T >
LinearTransform< Vector< T > >	linear_transform (wavelets::Wavelet const &wavelet, t_uint rows, t_uint cols=1)
	Thin linear-transform wrapper around 2d wavelets. More...

template<typename T >
LinearTransform< Vector< T > >	linear_transform (wavelets::SARA const &sara, t_uint rows, t_uint cols=1)
	Thin linear-transform wrapper around 2d wavelets. More...

template<typename T >
void	direct_transform (void out, void in, void **data)

template<typename T >
void	adjoint_transform (void out, void in, void **data)

template<typename T >
Vector< T >	target (sopt::LinearTransform< Vector< T >> const &sampling, sopt::Image< T > const &image)

template<typename T >
real_type< T >::type	sigma (sopt::LinearTransform< Vector< T >> const &sampling, sopt::Image< T > const &image)

template<typename T , typename RANDOM >
Vector< T >	dirty (sopt::LinearTransform< Vector< T >> const &sampling, sopt::Image< T > const &image, RANDOM &mersenne)

template<typename T >
real_type< T >::type	epsilon (sopt::LinearTransform< Vector< T >> const &sampling, sopt::Image< T > const &image)

Typedef Documentation

◆ Array

template<typename T = t_real>

using sopt::Array = typedef Eigen::Array<T, Eigen::Dynamic, 1>

A 1-dimensional list of elements of given type.

Operates coefficient-wise, not matrix-vector-wise

Definition at line 34 of file types.h.

◆ ConvergenceFunction

template<typename SCALAR = t_real>

using sopt::ConvergenceFunction = typedef std::function<bool(Vector<SCALAR> const &)>

Typical function signature for convergence.

Definition at line 52 of file types.h.

◆ Image

template<typename T = t_real>

using sopt::Image = typedef Eigen::Array<T, Eigen::Dynamic, Eigen::Dynamic>

A 2-dimensional list of elements of given type.

Operates coefficient-wise, not matrix-vector-wise

Definition at line 39 of file types.h.

◆ Matrix

template<typename T = t_real>

using sopt::Matrix = typedef Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>

A matrix of a given type.

Operates as mathematical matrix.

Definition at line 29 of file types.h.

◆ OperatorFunction

template<typename VECTOR = Vector<>>

using sopt::OperatorFunction = typedef std::function<void(VECTOR &, VECTOR const &)>

Typical function out = A*x.

Definition at line 43 of file types.h.

◆ ProximalFunction

template<typename SCALAR = t_real>

using sopt::ProximalFunction = typedef std::function<void(Vector<SCALAR> &output, typename real_type<SCALAR>::type const weight, Vector<SCALAR> const &input)>

Typical function signature for calls to proximal.

Definition at line 47 of file types.h.

◆ real_type

template<typename T >

using sopt::real_type = typedef details::underlying_value_type<T>

Gets to the underlying real type.

Definition at line 56 of file real_type.h.

◆ t_complex

using sopt::t_complex = typedef std::complex<t_real>

Root of the type hierarchy for (real) complex numbers.

Definition at line 19 of file types.h.

◆ t_int

using sopt::t_int = typedef int

Root of the type hierarchy for signed integers.

Definition at line 13 of file types.h.

◆ t_real

using sopt::t_real = typedef double

Root of the type hierarchy for real numbers.

Definition at line 17 of file types.h.

◆ t_uint

using sopt::t_uint = typedef size_t

Root of the type hierarchy for unsigned integers.

Definition at line 15 of file types.h.

◆ Vector

template<typename T = t_real>

using sopt::Vector = typedef Eigen::Matrix<T, Eigen::Dynamic, 1>

A vector of a given type.

Operates as mathematical vector.

Definition at line 24 of file types.h.

Function Documentation

◆ adjoint_transform()

template<typename T >

void sopt::adjoint_transform	(	void *	out,
		void *	in,
		void **	data
	)

Definition at line 27 of file cdata.h.

                                                          {
   CData<T> const &cdata = *(CData<T> *)data;
   using t_Vector = Eigen::Matrix<T, Eigen::Dynamic, 1>;
   t_Vector const eval = cdata.transform.adjoint() * t_Vector::Map((T *)in, cdata.nout);
   ++(((CData<T> *)data)->adjoint_calls);
   t_Vector::Map((T *)out, cdata.nin) = eval;
 }

References sopt::LinearTransform< VECTOR >::adjoint(), sopt::CData< T >::nin, sopt::CData< T >::nout, and sopt::CData< T >::transform.

◆ bisection_method()

template<typename K >

std::enable_if< std::is_same< t_real, K >::value, K >::type sopt::bisection_method	(	const K &	function_value,
		const std::function< K(K)> &	func,
		const K &	a,
		const K &	b,
		const t_real &	rel_convergence = `1e-4`
	)

Find root to a function within an interval.

Definition at line 18 of file bisection_method.h.

                                    {
   t_real lower_eta = a;
   t_real upper_eta = b;
   t_real relative_difference = 1;
   t_real eta = (a + b) * 0.5;
   SOPT_LOW_LOG("Starting bisection method over x ∈ [{}, {}], to estimate f(x) = {}", a, b,
                function_value);
   const auto estimate = [&](const K &x) { return func(x) - function_value; };
   const t_real eb = estimate(b);
   const t_real ea = estimate(a);
   if (eb == 0) return b;
   if (ea == 0) return a;
   if ((ea > 0 and eb > 0) or (ea < 0 and eb < 0))
     SOPT_THROW("f(a) = " << ea << " and f(b) = " << eb
                          << " have the wrong sign."
                             "Where a = "
                          << a << " and b = " << b
                          << " Bisection Method not applicable for "
                             "this function.");
   const auto sign = [&](const K &x) { return (x > 0) ? 1 : ((x < 0) ? -1 : 0); };
   // SOPT_LOW_LOG("Convergence when: |f((a+b)/2) -f(x)| < {} or |a - b| < {}", rel_convergence,
   //              rel_convergence);
   while (rel_convergence < relative_difference or
          std::abs(upper_eta - lower_eta) > rel_convergence) {
     if (upper_eta == lower_eta) SOPT_THROW("a == b, something is wrong.");
     eta = (lower_eta + upper_eta) * 0.5;
     auto const function_est = estimate(eta);
     if (sign(estimate(lower_eta)) == sign(estimate(eta)))
       lower_eta = eta;
     else
       upper_eta = eta;
     relative_difference = std::abs(function_est);
     assert(!(estimate(lower_eta) > 0 and estimate(upper_eta) > 0) and
            !(estimate(lower_eta) < 0 and estimate(upper_eta) < 0));
     //   SOPT_LOW_LOG("|f(x_0) - f(x)| = {}, x = {}, [{}, {}]", relative_difference, eta, lower_eta,
     //                upper_eta);
   }
   return eta;
 }

References a, b, SOPT_LOW_LOG, and SOPT_THROW.

Referenced by sopt::credible_region::find_credible_interval(), and TEST_CASE().

◆ chained_operators()

template<typename T0 , typename... T>

OperatorFunction<T0> sopt::chained_operators	(	OperatorFunction< T0 > const &	arg0,
		T const &...	args
	)

Definition at line 12 of file chained_operators.h.

                                                                                             {
   if (sizeof...(args) == 0) return arg0;
  
   std::vector<OperatorFunction<T0>> const funcs = {arg0, args...};
   const std::shared_ptr<T0> buffer = std::make_shared<T0>();
   OperatorFunction<T0> result = [funcs, buffer](T0 &output, T0 const &input) -> void {
     auto first = funcs.rbegin();
     auto const last = funcs.rend();
     if (funcs.size() == 1)
       (*first)(output, input);
     else if (funcs.size() % 2 == 1)
       (*first)(output, input);
     else {
       (*first)(*buffer, input);
       first++;
       (*first)(output, *buffer);
     }
     for (++first; first != last; first++) {
       (*first)(*buffer, output);
       first++;
       (*first)(output, *buffer);
     }
   };
   return result;
 }

Referenced by TEST_CASE().

◆ default_logger_name()

std::string sopt::default_logger_name ( )

inline

Default logger name.

Definition at line 47 of file config.in.h.

47 { return "@SOPT_LOGGER_NAME@"; }

◆ default_logging_level()

std::string sopt::default_logging_level ( )

inline

Default logging level.

Definition at line 44 of file config.in.h.

44 { return "@SOPT_TEST_LOG_LEVEL@"; }

◆ direct_transform()

template<typename T >

void sopt::direct_transform	(	void *	out,
		void *	in,
		void **	data
	)

Definition at line 19 of file cdata.h.

                                                         {
   CData<T> const &cdata = *(CData<T> *)data;
   using t_Vector = Eigen::Matrix<T, Eigen::Dynamic, 1>;
   t_Vector const eval = cdata.transform * t_Vector::Map((T *)in, cdata.nin);
   ++(((CData<T> *)data)->direct_calls);
   t_Vector::Map((T *)out, cdata.nout) = eval;
 }

References sopt::CData< T >::nin, sopt::CData< T >::nout, and sopt::CData< T >::transform.

◆ dirty()

template<typename T , typename RANDOM >

Vector<T> sopt::dirty	(	sopt::LinearTransform< Vector< T >> const &	sampling,
		sopt::Image< T > const &	image,
		RANDOM &	mersenne
	)

Definition at line 25 of file inpainting.h.

                                   {
   // values near the mean are the most likely
   // standard deviation affects the dispersion of generated values from the mean
   auto const y0 = target(sampling, image);
   std::normal_distribution<> gaussian_dist(0, sigma(sampling, image));
   Vector<T> y(y0.size());
   for (t_int i = 0; i < y0.size(); i++) y(i) = y0(i) + gaussian_dist(mersenne);
  
   return y;
 }

References mersenne(), sigma(), and target().

Referenced by main().

◆ epsilon()

template<typename T >

real_type<T>::type sopt::epsilon	(	sopt::LinearTransform< Vector< T >> const &	sampling,
		sopt::Image< T > const &	image
	)

Definition at line 38 of file inpainting.h.

                                                                {
   auto const y0 = target(sampling, image);
   auto const nmeasure = y0.size();
   return std::sqrt(nmeasure + 2 * std::sqrt(nmeasure)) * sigma(sampling, image);
 }

References sigma(), and target().

Referenced by function_cg(), main(), matrix_cg(), and TEST_CASE().

◆ gitref()

std::string sopt::gitref ( )

inline

Returns library git reference, if known.

Definition at line 41 of file config.in.h.

41 { return "@SOPT_GITREF@"; }

◆ l1_norm() [1/4]

template<typename T0 >

real_type<typename T0::Scalar>::type sopt::l1_norm ( Eigen::ArrayBase< T0 > const & input )

Computes L1 norm.

Definition at line 129 of file maths.h.

                                                                                    {
   return input.cwiseAbs().sum();
 }

◆ l1_norm() [2/4]

template<typename T0 , typename T1 >

real_type<typename T0::Scalar>::type sopt::l1_norm	(	Eigen::ArrayBase< T0 > const &	input,
		Eigen::ArrayBase< T1 > const &	weights
	)

Computes weighted L1 norm.

Definition at line 116 of file maths.h.

                                                                                          {
   if (weights.size() == 1) return input.cwiseAbs().sum() * std::abs(weights(0));
   return (input * weights).cwiseAbs().sum();
 }

Referenced by sopt::algorithm::L1GProximal< SCALAR >::function(), sopt::algorithm::TFGProximal< SCALAR >::function(), l1_norm(), main(), sopt::proximal::L1TightFrame< SCALAR >::objective(), TEST_CASE(), and sopt::objective_functions::unconstrained_l1_regularisation().

◆ l1_norm() [3/4]

template<typename T0 >

real_type<typename T0::Scalar>::type sopt::l1_norm ( Eigen::MatrixBase< T0 > const & input )

Computes L1 norm.

Definition at line 134 of file maths.h.

                                                                                     {
   return l1_norm(input.array());
 }

References l1_norm().

◆ l1_norm() [4/4]

template<typename T0 , typename T1 >

real_type<typename T0::Scalar>::type sopt::l1_norm	(	Eigen::MatrixBase< T0 > const &	input,
		Eigen::MatrixBase< T1 > const &	weight
	)

Computes weighted L1 norm.

Definition at line 123 of file maths.h.

                                                                                          {
   return l1_norm(input.array(), weight.array());
 }

References l1_norm().

◆ l2_norm() [1/4]

template<typename T0 >

real_type<typename T0::Scalar>::type sopt::l2_norm ( Eigen::ArrayBase< T0 > const & input )

Computes weighted L2 norm.

Definition at line 153 of file maths.h.

                                                                                    {
   typename T0::PlainObject w(1);
   w(0) = 1;
   return l2_norm(input, w);
 }

References l2_norm().

◆ l2_norm() [2/4]

template<typename T0 , typename T1 >

real_type<typename T0::Scalar>::type sopt::l2_norm	(	Eigen::ArrayBase< T0 > const &	input,
		Eigen::ArrayBase< T1 > const &	weights
	)

Computes weighted L2 norm.

Definition at line 140 of file maths.h.

                                                                                          {
   if (weights.size() == 1) return input.matrix().stableNorm() * std::abs(weights(0));
   return (input * weights).matrix().stableNorm();
 }

Referenced by l2_norm(), main(), TEST_CASE(), and sopt::objective_functions::unconstrained_regularisation().

◆ l2_norm() [3/4]

template<typename T0 >

real_type<typename T0::Scalar>::type sopt::l2_norm ( Eigen::MatrixBase< T0 > const & input )

Computes weighted L2 norm.

Definition at line 160 of file maths.h.

                                                                                     {
   typename T0::PlainObject w(1);
   w(0) = 1;
   return l2_norm(input.derived().array(), w.array());
 }

References l2_norm().

◆ l2_norm() [4/4]

template<typename T0 , typename T1 >

real_type<typename T0::Scalar>::type sopt::l2_norm	(	Eigen::MatrixBase< T0 > const &	input,
		Eigen::MatrixBase< T1 > const &	weights
	)

Computes weighted L2 norm.

Definition at line 147 of file maths.h.

                                                                                           {
   return l2_norm(input.derived().array(), weights.derived().array());
 }

References l2_norm().

◆ linear_transform() [1/10]

template<typename VECTOR >

LinearTransform<VECTOR> sopt::linear_transform	(	details::WrapFunction< VECTOR > const &	direct,
		details::WrapFunction< VECTOR > const &	adjoint
	)

Creates a linear transform from a pair of wrappers.

Definition at line 153 of file linear_transform.h.

                                                                                      {
   return {direct, adjoint};
 }

◆ linear_transform() [2/10]

template<typename DERIVED >

LinearTransform<Vector<typename DERIVED::Scalar> > sopt::linear_transform ( Eigen::MatrixBase< DERIVED > const & A )

Helper function to creates a function operator.

Definition at line 234 of file linear_transform.h.

                                        {
   details::MatrixToLinearTransform<Matrix<typename DERIVED::Scalar>> const matrix(A);
   if (A.rows() == A.cols())
     return {matrix, matrix.adjoint()};
   else {
     t_int const gcd = details::gcd(A.cols(), A.rows());
     t_int const a = A.cols() / gcd;
     t_int const b = A.rows() / gcd;
     return {matrix, matrix.adjoint(), {{b, a, 0}}};
   }
 }

References a, sopt::details::MatrixToLinearTransform< EIGEN >::adjoint(), b, and sopt::details::gcd().

◆ linear_transform() [3/10]

template<typename VECTOR >

LinearTransform<VECTOR>& sopt::linear_transform ( LinearTransform< VECTOR > & passthrough )

Convenience no-op function.

Definition at line 148 of file linear_transform.h.

                                                                                 {
   return passthrough;
 }

◆ linear_transform() [4/10]

template<typename VECTOR >

LinearTransform<VECTOR> sopt::linear_transform	(	OperatorFunction< VECTOR > const &	direct,
		OperatorFunction< VECTOR > const &	indirect,
		std::array< t_int, 3 > const &	sizes = `{{1, 1, 0}}`
	)

Helper function to creates a function operator

Parameters

[in]	direct	function with signature void(VECTOR&, VECTOR const&) which applies a linear operator to a vector.
[in]	indirect	function with signature void(VECTOR&, VECTOR const&) which applies a the conjugate transpose linear operator to a vector.
[in]	sizes	3 integer elements (a, b, c) such that if the input to linear operator is of size N, then the output is of size (a * N) / b + c. A similar quantity is deduced for the indirect operator.

Definition at line 124 of file linear_transform.h.

                                                                            {{1, 1, 0}}) {
   return {direct, indirect, sizes};
 }

Referenced by sopt::algorithm::SDMM< SCALAR >::append(), main(), sopt::algorithm::ImagingForwardBackward< SCALAR >::Phi(), sopt::algorithm::ImagingProximalADMM< SCALAR >::Phi(), sopt::algorithm::ImagingPrimalDual< SCALAR >::Phi(), sopt::algorithm::L2ForwardBackward< SCALAR >::Phi(), sopt::algorithm::ProximalADMM< SCALAR >::Phi(), sopt::algorithm::PrimalDual< SCALAR >::Phi(), sopt::algorithm::TVPrimalDual< SCALAR >::Phi(), sopt::algorithm::ImagingPrimalDual< SCALAR >::Psi(), sopt::proximal::L1TightFrame< SCALAR >::Psi(), sopt::algorithm::PrimalDual< SCALAR >::Psi(), sopt::algorithm::TVPrimalDual< SCALAR >::Psi(), and TEST_CASE().

◆ linear_transform() [5/10]

template<typename VECTOR >

LinearTransform<VECTOR> sopt::linear_transform	(	OperatorFunction< VECTOR > const &	direct,
		std::array< t_int, 3 > const &	dsizes,
		OperatorFunction< VECTOR > const &	indirect,
		std::array< t_int, 3 > const &	isizes
	)

Helper function to creates a function operator

Parameters

[in]	direct	function with signature void(VECTOR&, VECTOR const&) which applies a linear operator to a vector.
[in]	dsizes	3 integer elements (a, b, c) such that if the input to the linear operator is of size N, then the output is of size (a * N) / b + c.
[in]	indirect	function with signature void(VECTOR&, VECTOR const&) which applies a the conjugate transpose linear operator to a vector.
[in]	dsizes	3 integer elements (a, b, c) such that if the input to the indirect linear operator is of size N, then the output is of size (a * N) / b + c.

Definition at line 139 of file linear_transform.h.

                                                                            {
   return {direct, dsizes, indirect, isizes};
 }

◆ linear_transform() [6/10]

template<typename T >

LinearTransform<Vector<T> > sopt::linear_transform ( Sampling const & sampling )

Returns linear transform version of this object.

Definition at line 82 of file sampling.h.

                                                                       {
   return linear_transform<Vector<T>>(
       [sampling](Vector<T> &out, Vector<T> const &x) { sampling(out, x); },
       {{0, 1, static_cast<t_int>(sampling.rows())}},
       [sampling](Vector<T> &out, Vector<T> const &x) { sampling.adjoint(out, x); },
       {{0, 1, static_cast<t_int>(sampling.cols())}});
 }

References sopt::Sampling::adjoint(), sopt::Sampling::cols(), and sopt::Sampling::rows().

◆ linear_transform() [7/10]

template<typename T >

LinearTransform<Vector<T> > sopt::linear_transform ( wavelets::SARA const & sara )

Thin linear-transform wrapper around 1d sara operator.

Note: Because of the way Purify defines things, Ψ^T is actually the transform from signal to coefficients.

Definition at line 183 of file wavelets.h.

                                                                       {
   return details::linear_transform<T, wavelets::SARA>(sara);
 }

◆ linear_transform() [8/10]

template<typename T >

LinearTransform<Vector<T> > sopt::linear_transform	(	wavelets::SARA const &	sara,
		t_uint	rows,
		t_uint	cols = `1`
	)

Thin linear-transform wrapper around 2d wavelets.

Parameters

[in]	sara	SARA wavelet dictionary
[in]	rows	Number of rows in the image
[in]	cols	Number of columns in the image

Note: Because of the way Purify defines things, Ψ^T is actually the transform from signal to coefficients.

Definition at line 202 of file wavelets.h.

                                                              {
   return details::linear_transform<T, wavelets::SARA>(sara, rows, cols, sara.size());
 }

References cols, and rows.

◆ linear_transform() [9/10]

template<typename T >

LinearTransform<Vector<T> > sopt::linear_transform ( wavelets::Wavelet const & wavelet )

Thin linear-transform wrapper around 1d wavelets.

Warning: Because of the way Purify defines things, Ψ^T is actually the transform from signal to coefficients.

Definition at line 175 of file wavelets.h.

                                                                             {
   return details::linear_transform<T, wavelets::Wavelet>(wavelet);
 }

◆ linear_transform() [10/10]

template<typename T >

LinearTransform<Vector<T> > sopt::linear_transform	(	wavelets::Wavelet const &	wavelet,
		t_uint	rows,
		t_uint	cols = `1`
	)

Thin linear-transform wrapper around 2d wavelets.

Note: Because of the way Purify defines things, Ψ^T is actually the transform from signal to coefficients.

Definition at line 191 of file wavelets.h.

                                                              {
   return details::linear_transform<T, wavelets::Wavelet>(wavelet, rows, cols);
 }

References cols, and rows.

◆ linear_transform_identity()

template<typename SCALAR >

LinearTransform<Vector<SCALAR> > sopt::linear_transform_identity ( )

Helper function to create a linear transform that's just the identity.

Definition at line 249 of file linear_transform.h.

                                                             {
   return {[](Vector<SCALAR> &out, Vector<SCALAR> const &in) { out = in; },
           [](Vector<SCALAR> &out, Vector<SCALAR> const &in) { out = in; }};
 }

◆ number_of_threads_in_tests()

constexpr std::size_t sopt::number_of_threads_in_tests ( )

inlineconstexpr

Number of threads used during testing.

Definition at line 51 of file config.in.h.

51 { return @SOPT_DEFAULT_OPENMP_THREADS@; }

◆ positive_quadrant()

template<typename T >

Eigen::CwiseUnaryOp<const details::ProjectPositiveQuadrant<typename T::Scalar>, const T> sopt::positive_quadrant ( Eigen::DenseBase< T > const & input )

Expression to create projection onto positive quadrant.

Definition at line 60 of file maths.h.

                                                   {
   using Projector = details::ProjectPositiveQuadrant<typename T::Scalar>;
   using UnaryOp = Eigen::CwiseUnaryOp<const Projector, const T>;
   return UnaryOp(input.derived(), Projector());
 }

Referenced by main(), sopt::proximal::positive_quadrant(), and TEST_CASE().

◆ sigma()

template<typename T >

real_type<T>::type sopt::sigma	(	sopt::LinearTransform< Vector< T >> const &	sampling,
		sopt::Image< T > const &	image
	)

Definition at line 17 of file inpainting.h.

                                                              {
   auto constexpr snr = 30.0;
   auto const y0 = target(sampling, image);
   return y0.stableNorm() / std::sqrt(y0.size()) * std::pow(10.0, -(snr / 20.0));
 }

References target().

Referenced by dirty(), epsilon(), sopt::ONNXDifferentiableFunc< SCALAR >::function(), sopt::ONNXDifferentiableFunc< SCALAR >::gradient(), sopt::L2DifferentiableFunc< SCALAR >::L2DifferentiableFunc(), main(), and TEST_CASE().

◆ soft_threshhold() [1/4]

template<typename T >

Eigen::CwiseUnaryOp<const details::SoftThreshhold<typename T::Scalar>, const T> sopt::soft_threshhold	(	Eigen::DenseBase< T > const &	input,
		typename real_type< typename T::Scalar >::type const &	threshhold
	)

Expression to create soft-threshhold.

Definition at line 68 of file maths.h.

                                                                 {
   using Scalar = typename T::Scalar;
   using Real = typename real_type<Scalar>::type;
   return Eigen::CwiseUnaryOp<const details::SoftThreshhold<typename T::Scalar>, const T>{
       input.derived(), std::bind(soft_threshhold<Scalar>, std::placeholders::_1, Real(threshhold))};
 }

◆ soft_threshhold() [2/4]

template<typename T0 , typename T1 >

std::enable_if<std::is_arithmetic<typename T0::Scalar>::value and std::is_arithmetic<typename T1::Scalar>::value, Eigen::CwiseBinaryOp<typename T0::Scalar (*)(typename T0::Scalar const &, typename T1::Scalar const &), const T0, const T1> >::type sopt::soft_threshhold	(	Eigen::DenseBase< T0 > const &	input,
		Eigen::DenseBase< T1 > const &	threshhold
	)

Expression to create soft-threshhold with multiple parameters.

Operates over a vector of threshholds: out(i) = soft_threshhold(x(i), h(i)) Threshhold and input vectors must have the same size and type. The latter condition is enforced by CwiseBinaryOp, unfortunately.

Definition at line 87 of file maths.h.

                                                                                        {
   if (input.size() != threshhold.size())
     SOPT_THROW("Threshhold and input should have the same size");
   return {input.derived(), threshhold.derived(), soft_threshhold<typename T0::Scalar>};
 }

References SOPT_THROW.

◆ soft_threshhold() [3/4]

template<typename T0 , typename T1 >

std::enable_if< is_complex<typename T0::Scalar>::value and std::is_arithmetic<typename T1::Scalar>::value, Eigen::CwiseBinaryOp< typename T0::Scalar (*)(typename T0::Scalar const &, typename T0::Scalar const &), const T0, decltype(std::declval<const T1>).template cast<typename T0::Scalar>))> >::type sopt::soft_threshhold	(	Eigen::DenseBase< T0 > const &	input,
		Eigen::DenseBase< T1 > const &	threshhold
	)

Expression to create soft-threshhold with multiple parameters.

Operates over a vector of threshholds: out(i) = soft_threshhold(x(i), h(i)) Threshhold and input vectors must have the same size and type. The latter condition is enforced by CwiseBinaryOp, unfortunately. So we cast threshhold from real to complex and back.

Definition at line 103 of file maths.h.

                                                                                        {
   if (input.size() != threshhold.size())
     SOPT_THROW("Threshhold and input should have the same size: ")
         << threshhold.size() << " vs " << input.size();
   using Complex = typename T0::Scalar;
   auto const func = [](Complex const &x, Complex const &t) -> Complex {
     return soft_threshhold(x, t.real());
   };
   return {input.derived(), threshhold.derived().template cast<Complex>(), func};
 }

References soft_threshhold(), and SOPT_THROW.

◆ soft_threshhold() [4/4]

template<typename SCALAR >

std::enable_if<std::is_arithmetic<SCALAR>::value or is_complex<SCALAR>::value, SCALAR>::type sopt::soft_threshhold	(	SCALAR const &	x,
		typename real_type< SCALAR >::type const &	threshhold
	)

abs(x) < threshhold ? 0: x - sgn(x) * threshhold

Definition at line 29 of file maths.h.

                                                                                    {
   auto const normalized = std::abs(x);
   return normalized < threshhold ? SCALAR(0) : (x * (SCALAR(1) - threshhold / normalized));
 }

Referenced by sopt::proximal::l1_norm(), main(), sopt::proximal::L1TightFrame< SCALAR >::operator()(), soft_threshhold(), and TEST_CASE().

◆ standard_deviation() [1/2]

template<typename T >

real_type<typename T::Scalar>::type sopt::standard_deviation ( Eigen::ArrayBase< T > const & x )

Computes the standard deviation of a vector.

Definition at line 16 of file maths.h.

                                                                                         {
   return (x - x.mean()).matrix().stableNorm() / std::sqrt(x.size());
 }

Referenced by sopt::algorithm::Reweighted< ALGORITHM >::operator()(), standard_deviation(), and TEST_CASE().

◆ standard_deviation() [2/2]

template<typename T >

real_type<typename T::Scalar>::type sopt::standard_deviation ( Eigen::MatrixBase< T > const & x )

Computes the standard deviation of a vector.

Definition at line 21 of file maths.h.

                                                                                          {
   return standard_deviation(x.array());
 }

References standard_deviation().

◆ target()

template<typename T >

Vector<T> sopt::target	(	sopt::LinearTransform< Vector< T >> const &	sampling,
		sopt::Image< T > const &	image
	)

Definition at line 12 of file inpainting.h.

                                                                                             {
   return sampling * Vector<T>::Map(image.data(), image.size());
 }

Referenced by dirty(), epsilon(), sopt::algorithm::L2ForwardBackward< SCALAR >::operator()(), sigma(), sopt::algorithm::L2ForwardBackward< SCALAR >::target(), and TEST_CASE().

◆ tv_norm() [1/4]

template<typename T0 >

real_type<typename T0::Scalar>::type sopt::tv_norm ( Eigen::ArrayBase< T0 > const & input )

Computes weighted tv norm.

Definition at line 192 of file maths.h.

                                                                                    {
   typename T0::PlainObject w(1);
   w(0) = 1;
   return tv_norm(input, w);
 }

References tv_norm().

◆ tv_norm() [2/4]

template<typename T0 , typename T1 >

real_type<typename T0::Scalar>::type sopt::tv_norm	(	Eigen::ArrayBase< T0 > const &	input,
		Eigen::ArrayBase< T1 > const &	weights
	)

Computes weighted TV norm.

Definition at line 168 of file maths.h.

                                                                                          {
   const auto size = input.size() / 2;
   if (weights.size() == 1)
     return (input.segment(0, size).square() + input.segment(size, size).square())
                .cwiseAbs()
                .sqrt()
                .matrix()
                .sum() *
            std::abs(weights(0));
   return std::abs(
       ((input.segment(0, size).square() + input.segment(size, size).square()).cwiseAbs().sqrt() *
        weights)
           .matrix()
           .sum());
 }

Referenced by tv_norm().

◆ tv_norm() [3/4]

template<typename T0 >

real_type<typename T0::Scalar>::type sopt::tv_norm ( Eigen::MatrixBase< T0 > const & input )

Computes weighted TV norm.

Definition at line 199 of file maths.h.

                                                                                     {
   typename T0::PlainObject w(1);
   w(0) = 1;
   return tv_norm(input.derived().array(), w.array());
 }

References tv_norm().

◆ tv_norm() [4/4]

template<typename T0 , typename T1 >

real_type<typename T0::Scalar>::type sopt::tv_norm	(	Eigen::MatrixBase< T0 > const &	input,
		Eigen::MatrixBase< T1 > const &	weights
	)

Computes weighted TV norm.

Definition at line 186 of file maths.h.

                                                                                           {
   return tv_norm(input.derived().array(), weights.derived().array());
 }

References tv_norm().

◆ version()

std::string sopt::version ( )

inline

Returns library version.

Definition at line 32 of file config.in.h.

32 { return "@SOPT_VERSION@"; }

◆ version_tuple()

std::tuple<uint8_t, uint8_t, uint8_t> sopt::version_tuple ( )

inline

Returns library version.

Definition at line 35 of file config.in.h.

                                                            {
   return std::tuple<uint8_t, uint8_t, uint8_t>(
       @SOPT_VERSION_MAJOR@, @SOPT_VERSION_MINOR@, @SOPT_VERSION_PATCH@);
 }

Namespaces

Classes

Typedefs

Functions

Typedef Documentation

◆ Array

◆ ConvergenceFunction

◆ Image

◆ Matrix

◆ OperatorFunction

◆ ProximalFunction

◆ real_type

◆ t_complex

◆ t_int

◆ t_real

◆ t_uint

◆ Vector

Function Documentation

◆ adjoint_transform()

◆ bisection_method()

◆ chained_operators()

◆ default_logger_name()

◆ default_logging_level()

◆ direct_transform()

◆ dirty()

◆ epsilon()

◆ gitref()

◆ l1_norm() [1/4]

◆ l1_norm() [2/4]

◆ l1_norm() [3/4]

◆ l1_norm() [4/4]

◆ l2_norm() [1/4]

◆ l2_norm() [2/4]

◆ l2_norm() [3/4]

◆ l2_norm() [4/4]

◆ linear_transform() [1/10]

◆ linear_transform() [2/10]

◆ linear_transform() [3/10]

◆ linear_transform() [4/10]

◆ linear_transform() [5/10]

◆ linear_transform() [6/10]

◆ linear_transform() [7/10]

◆ linear_transform() [8/10]

◆ linear_transform() [9/10]

◆ linear_transform() [10/10]

◆ linear_transform_identity()

◆ number_of_threads_in_tests()

◆ positive_quadrant()

◆ sigma()

◆ soft_threshhold() [1/4]

◆ soft_threshhold() [2/4]

◆ soft_threshhold() [3/4]

◆ soft_threshhold() [4/4]

◆ standard_deviation() [1/2]

◆ standard_deviation() [2/2]

◆ target()

◆ tv_norm() [1/4]

◆ tv_norm() [2/4]

◆ tv_norm() [3/4]

◆ tv_norm() [4/4]

◆ version()

◆ version_tuple()