interior point variables and routines specific to the primal dual complementarity conditions of a positive semidefinite cone with special routines for handling the bundle and the trace constraint More...

#include <PSCIPBundleBlock.hxx>

Inheritance diagram for ConicBundle::PSCIPBundleBlock:

Public Member Functions
void	clear (CH_Matrix_Classes::Integer dim=0)
	reset all point information to zero for dimension dim, the rest to zero

	PSCIPBundleBlock (CH_Matrix_Classes::Integer dim=0, CBout *cb=0, int cbinc=-1)
	default constructor, allows to intialize the order of the matrix cone

	~PSCIPBundleBlock ()
	destructor

virtual InteriorPointBundleBlock *	clone ()
	returns a clone

virtual int	copy_from (InteriorPointBundleBlock *)
	copies to content of the argument to this; to work *this must be a clone of the argument; sofar this is only needed for comparative testing

virtual void	set_oracle_data (QPModelOracleDataObject *in_oracle_data)
	allows to pass on additional information about the oracle if required

virtual CH_Matrix_Classes::Integer	dim_bundle () const
	returns the number of consecutive bundle elements this cone makes use of

virtual CH_Matrix_Classes::Real	evaluate_trace_x ()
	return the "trace" value of the current point

virtual CH_Matrix_Classes::Real	evaluate_trace_z ()
	return the "trace" value of the current point

virtual CH_Matrix_Classes::Real	evaluate_trace_dx ()
	return the change in "trace" value caused by the current x step

virtual int	add_trace (CH_Matrix_Classes::Matrix &vec, CH_Matrix_Classes::Real alpha, CH_Matrix_Classes::Integer startindex)
	add alpha*trace_vec to vec starting at startindex

virtual int	set_xizinvsqrt_trace (CH_Matrix_Classes::Matrix &vec, CH_Matrix_Classes::Integer startindex)
	set the trace premultiplied by sqrt(inv(xiz)) in vec[startindex+0,...,startindex+dim_bundle()-1]

virtual CH_Matrix_Classes::Matrix &	B_times (const CH_Matrix_Classes::Matrix &A, CH_Matrix_Classes::Matrix &C, CH_Matrix_Classes::Real alpha, CH_Matrix_Classes::Real beta, int Btrans, int Atrans, CH_Matrix_Classes::Integer startindex_model, MinorantBundle &globalbundle, CH_Matrix_Classes::Integer startindex_bundle)
	C=betaC+alphaB*A where B and A may be transposed; carry out the model part of this beginning at startindex_model and beta for the part, that is added to (the calling routine has to make sure beta is not executed repeatedly if the same part is affected by other models as well)

virtual CH_Matrix_Classes::Matrix &	times_B (const CH_Matrix_Classes::Matrix &A, CH_Matrix_Classes::Matrix &C, CH_Matrix_Classes::Real alpha, CH_Matrix_Classes::Real beta, int Atrans, int Btrans, CH_Matrix_Classes::Integer startindex_model, MinorantBundle &globalbundle, CH_Matrix_Classes::Integer startindex_bundle)
	C=betaC+alphaA*B where B and B may be transposed; carry out the model part of this beginning at startindex_model.

virtual CH_Matrix_Classes::Symmatrix &	add_BDBt (const CH_Matrix_Classes::Matrix &diagvec, CH_Matrix_Classes::Symmatrix &bigS, bool minus, CH_Matrix_Classes::Integer startindex, CH_Matrix_Classes::Matrix &Bt, CH_Matrix_Classes::Integer startindex_model, MinorantBundle &globalbundle, CH_Matrix_Classes::Integer startindex_bundle)
	add the main diagonal block tranpose(projection)diagvecprojection to bigS starting at startindex

virtual CH_Matrix_Classes::Matrix &	get_Bt (CH_Matrix_Classes::Matrix &Bt, CH_Matrix_Classes::Integer startindex_model, MinorantBundle &global_bundle, CH_Matrix_Classes::Integer startindex_bundle)
	get the current matrix for the coupling matrix Bt in the first row of blocks

virtual int	add_modelx_aggregate (CH_Matrix_Classes::Real &val, CH_Matrix_Classes::Matrix &vec, MinorantBundle &global_bundle, CH_Matrix_Classes::Integer startindex_bundle)
	adds opB transposed times modelx (without constant affine term) to the arguments

virtual int	get_sysviol_model (CH_Matrix_Classes::Matrix &sysviol_model, CH_Matrix_Classes::Integer startindex_model, const CH_Matrix_Classes::Matrix &dy, const CH_Matrix_Classes::Real deltatrdual, MinorantBundle &global_bundle, CH_Matrix_Classes::Integer startindex_bundle)
	set the model violation for the current system solution for the precomputed rhs on basis of the y and tracedual set in connection with set_bundle_z()/add_trace_to_diff_model or do_bundle_step()

virtual int	set_bundle_z (const CH_Matrix_Classes::Matrix &y, MinorantBundle &global_bundle, CH_Matrix_Classes::Integer startindex_bundle, CH_Matrix_Classes::Real &add_center_value)
	set z to the slack of the bundle and return a value>=0 that needs to be added to make it feasible

virtual int	add_trace_to_diff_model (CH_Matrix_Classes::Real trace_dual)
	add trace_dual*trace to diff_model for the right hand side (negative of current model violation)

virtual CH_Matrix_Classes::Real	dualviol_2normsqr ()
	return the squared Euclidean norm of the dual model violation

virtual int	do_bundle_step (CH_Matrix_Classes::Real alpha, const CH_Matrix_Classes::Matrix &y, MinorantBundle &globalbundle, CH_Matrix_Classes::Integer startindex_bundle, CH_Matrix_Classes::Real tracedual, CH_Matrix_Classes::Real trace_rhs)
	move to (x+alphadx, z+alphadz), update diff_model and possibly reduce the model size if some part is too small relatvie to trace_rhs

virtual int	set_modelrhs (CH_Matrix_Classes::Matrix &globalrhs, CH_Matrix_Classes::Real rhsmu, CH_Matrix_Classes::Real rhscorr, CH_Matrix_Classes::Integer startindex_model)
	If mu is not zero, always add the centering term for this mu as well;.

virtual int	add_BtinvsysB (CH_Matrix_Classes::Symmatrix &globalsys, const MinorantBundle &bundle, CH_Matrix_Classes::Integer startindex_bundle)
	add the "scaled" minorant outer products to globalsys, where the correct minroants start at the given index

int	Schur_transform_bundle (CH_Matrix_Classes::Matrix &glob_lowrank, MinorantBundle &globalbundle, CH_Matrix_Classes::Integer startindex_bundle, CH_Matrix_Classes::Matrix &trafotrace, CH_Matrix_Classes::Integer startindex_trace)
	provides basic information for low rank preconditioning (in the extreme case solving) for the case of Schur complementing the model and the trace into the quadratic block More...

virtual int	add_bundle_xizinv_diagonal (CH_Matrix_Classes::Matrix &diagonal, CH_Matrix_Classes::Matrix &ipBtrvec, MinorantBundle &globalbundle, CH_Matrix_Classes::Integer startindex_bundle, const CH_Matrix_Classes::Matrix &trafotrace, CH_Matrix_Classes::Integer startindex_trace)
	add diag(Btsqrt(invsys)(I-lambdatrvectrvec')sqrt(invsys)B) to diagonal More...

virtual int	add_pcsubspace (CH_Matrix_Classes::Matrix &lowrank, CH_Matrix_Classes::Matrix &sigma_guess, const CH_Matrix_Classes::Matrix &Diag_inv, CH_Matrix_Classes::Real minval, CH_Matrix_Classes::Real diaginvval, CH_Matrix_Classes::Matrix &minus_trmult, CH_Matrix_Classes::Real schur_trace, MinorantBundle &globalbundle, CH_Matrix_Classes::Integer startindex_bundle)
	append to lowrank "large" columns that should serve well for generating a low rank projection of the Schur complemented model part. For each column i the coordinate sigma_guess(i) gives the Diag_inv-norm for this column. The parameter minval asks to ignore columns whose norms are smaller than minval. If diaginvval is positive, the vector Diag_inv is this value times the all ones vector. More...

int	add_bundle_xizinvsqrt_projection (CH_Matrix_Classes::Matrix &glob_lowrank, CH_Matrix_Classes::Matrix &subspace, CH_Matrix_Classes::Integer startindex_subsspace, MinorantBundle &globalbundle, CH_Matrix_Classes::Integer startindex_bundle)
	add bundlesqrt(inv(xiz))subspace to glob_lowrank with bundle(:,si_bundle+1:si_bundle+dim_bundle()-1) and subspace(si_subsp:si_subsp+dim_bundle,:); sqrt(inv(xiz)) has to match that used in set_xizinvsqrt_trace()

virtual int	add_BtinvsysB_times (const CH_Matrix_Classes::Matrix &in_vec, CH_Matrix_Classes::Matrix &out_vec, CH_Matrix_Classes::Real zeta_inval, CH_Matrix_Classes::Real *zeta_outval, MinorantBundle &globalbundle, CH_Matrix_Classes::Integer startindex_bundle)
	out_vec+=BtinvsysB*in_vec

virtual int	set_dx_xizsolvestep (const CH_Matrix_Classes::Matrix &step_y, const CH_Matrix_Classes::Real step_trdual, MinorantBundle &globalbundle, CH_Matrix_Classes::Integer startindex_bundle)
	compute dx (and then dz) given step_y and step_trdual on basis of the last rhs computed for the model block

int	get_pscx (CH_Matrix_Classes::Matrix &pscx_eigs, CH_Matrix_Classes::Matrix &pscx_vecs, CH_Matrix_Classes::Real &pscx_growthrate, CH_Matrix_Classes::Matrix &pscx_primalgrowth, CH_Matrix_Classes::Matrix &pscx_dualgrowth)
	after the bundle subproblem is solved, this retrieves the local psc solution i as eigenvalue factorization; if pscx_activity is set, the value indicates the guess on the active rank, where trace_bound may serve to specify the expected range of values

Public Member Functions inherited from ConicBundle::InteriorPointBundleBlock
	InteriorPointBundleBlock (CBout *cb=0, int cbinc=-1)
	default constructor

virtual	~InteriorPointBundleBlock ()
	virtual destructor

Public Member Functions inherited from ConicBundle::InteriorPointBlock
	InteriorPointBlock (CBout *cb=0, int cbinc=-1)
	default constructor

virtual	~InteriorPointBlock ()
	virtual destructor (implemented in InteriorPointBundleBlock.cxx)

Public Member Functions inherited from ConicBundle::CBout
virtual void	set_out (std::ostream *out=0, int print_level=1)
	Specifies the output level (out==NULL: no output at all, out!=NULL and level=0: errors and warnings, level>0 increasingly detailed information) More...

virtual void	set_cbout (const CBout *cb, int incr=-1)
	Specifies the output level relative to the given CBout class. More...

void	clear_cbout ()
	reset to default settings (out=0,print_level=1)

	CBout (const CBout *cb=0, int incr=-1)
	calls set_cbout

	CBout (std::ostream *outp, int pl=1)
	initialize correspondingly

	CBout (const CBout &cb, int incr=0)
	copy constructor

virtual bool	cb_out (int pl=-1) const
	Returns true if out!=0 and (pl<print_level), pl<0 should be used for WARNINGS and ERRORS only, pl==0 for usual output.

std::ostream &	get_out () const
	If cb_out() returned true, this returns the output stream, but it will abort if called with out==0.

std::ostream *	get_out_ptr () const
	returns the pointer to the output stream

int	get_print_level () const
	returns the print_level

virtual int	mfile_data (std::ostream &out) const
	writes problem data to the given outstream

Public Member Functions inherited from ConicBundle::PSCIPBlock
	PSCIPBlock (CH_Matrix_Classes::Integer dim=0, CBout *cb=0, int cbinc=-1)
	default constructor, alos allows to set the order

	~PSCIPBlock ()
	destructor

virtual CH_Matrix_Classes::Integer	get_vecdim () const
	return the length of the svec reprensentation

virtual int	center_x (CH_Matrix_Classes::Real val, bool add=false)
	set x to value"one" to x, or if add==true, add value"one" to x

virtual int	center_z (CH_Matrix_Classes::Real val, bool add=false)
	set z to value"one" to z, or if add==true, add value"one" to z

virtual int	set_x (const CH_Matrix_Classes::Matrix &vec, CH_Matrix_Classes::Integer startindex, CH_Matrix_Classes::Real &add_center_value)
	set x to the values of vec[startindex+0,+1 ...,+(vecdim-1)] and return in add_center_value a value>=0 that needs to be added to make it feasible

virtual int	set_z (const CH_Matrix_Classes::Matrix &vec, CH_Matrix_Classes::Integer startindex, CH_Matrix_Classes::Real &add_center_value)
	set z to the values of vec[startindex+0,+1 ...,+(vecdim-1)] and add sufficient center to make z feasible, return this value>=0 in added_center_value

virtual int	vecgetsax (CH_Matrix_Classes::Matrix &vec, CH_Matrix_Classes::Integer startindex, CH_Matrix_Classes::Real a=1., bool add=false)
	on vec[startindex+0,+1 ...,+(vecdim-1)] put or add a * x into vec for a real number a

virtual int	vecgetsaz (CH_Matrix_Classes::Matrix &vec, CH_Matrix_Classes::Integer startindex, CH_Matrix_Classes::Real a=1., bool add=false)
	on vec[startindex+0,+1 ...,+(vecdim-1)] put or add a * z into vec for a real number a

virtual int	get_mu_info (CH_Matrix_Classes::Integer &mudim, CH_Matrix_Classes::Real &tr_xz, CH_Matrix_Classes::Real &tr_xdzpdxz, CH_Matrix_Classes::Real &tr_dxdz, CH_Matrix_Classes::Real &min_xz, CH_Matrix_Classes::Real &max_xz) const
	add dimensions of the primal-dual pairs to mudim and add the "trace" (the inner product with center) of the respective primal-dual pair products for the current step; update the min and max values of x_i*z_i

virtual int	get_nbh_info (CH_Matrix_Classes::Integer mudim, CH_Matrix_Classes::Real tr_xz, CH_Matrix_Classes::Real tr_xdzpdxz, CH_Matrix_Classes::Real tr_dxdz, CH_Matrix_Classes::Real nbh_ubnd, CH_Matrix_Classes::Real &alpha, CH_Matrix_Classes::Real &max_nbh, CH_Matrix_Classes::Real &nrmsqr_xz, CH_Matrix_Classes::Real &nrmsqr_xdzpdxz, CH_Matrix_Classes::Real &nrmsqr_dxdz, CH_Matrix_Classes::Real &ip_xz_xdzpdxz, CH_Matrix_Classes::Real &ip_xz_dxdz, CH_Matrix_Classes::Real &ip_dxdz_xdzpdxz) const
	for limiting the stepsize with respect to the neighborhood this information about norms and inner products of x(.)z-tr_xz-tr_xz/mudim(.)1, x.()dz+dx(.)z-tr_xdzpdxz/mudim(.)1, and dx(.)dz-tr_dxdz/mudim(.)1 is required, each block adds* its contribution to the numbers

virtual int	linesearch (CH_Matrix_Classes::Real &alpha) const
	if necessary, reduce alpha to the biggest value so that feasibility is maintained with this step size

virtual int	add_muxinv (CH_Matrix_Classes::Matrix &rhs, CH_Matrix_Classes::Integer startindex, CH_Matrix_Classes::Real rhsmu, CH_Matrix_Classes::Real rhscorr, bool minus=false)
	compute the complementarity_rhs=rhsmuxi-rhscorrxidxdz (wihtout "-z") for mu=rhsmu and for corrector for factor rhscorr>0., store this and add it to rhs

virtual int	set_dx (const CH_Matrix_Classes::Matrix &rhs, CH_Matrix_Classes::Integer startindex)
	extract dx from rhs at startindex and compute at the same time dz (=-sys dx -z +complentarity_rhs);

virtual int	set_dx_xizsolverhs (const CH_Matrix_Classes::Matrix &rhs, CH_Matrix_Classes::Integer startindex)
	compute dx=sysinv*rhs and at the same time dz (=-rhs -z +complentarity_rhs);

virtual int	apply_xizinv (CH_Matrix_Classes::Matrix &rhs, CH_Matrix_Classes::Integer startindex, bool minus=false)
	compute sysinv*rhs into rhs, possibly with a negative sign

virtual int	apply_xiz (CH_Matrix_Classes::Matrix &rhs, CH_Matrix_Classes::Integer startindex, bool minus=false)
	compute sys*rhs into rhs, possibly with a negative sign

virtual int	do_step (CH_Matrix_Classes::Real alpha)
	move to (x+alphadx, z+alphadz)

virtual int	add_AxizinvAt (const CH_Matrix_Classes::Matrix &A, CH_Matrix_Classes::Symmatrix &globalsys, bool minus=false, bool Atrans=false)
	add the Schur complement to a big system matrix

virtual int	add_xiz (CH_Matrix_Classes::Symmatrix &globalsys, CH_Matrix_Classes::Integer startindex, bool minus=false)
	add (or subract if minus==true) the system matrix to a big system matrix starting at startindex

virtual int	get_vecx (CH_Matrix_Classes::Matrix &vecx, CH_Matrix_Classes::Integer startindex)
	return the vector form of x

virtual int	get_vecz (CH_Matrix_Classes::Matrix &vecz, CH_Matrix_Classes::Integer startindex)
	return the vector form of z

virtual int	get_vecdx (CH_Matrix_Classes::Matrix &vecdx, CH_Matrix_Classes::Integer startindex)
	return the vector form of dx, 1 if not available

virtual int	get_vecdz (CH_Matrix_Classes::Matrix &vecdz, CH_Matrix_Classes::Integer startindex)
	return the vector form of dz, 1 if not available

Private Member Functions
CH_Matrix_Classes::Integer	active_rank (const CH_Matrix_Classes::Matrix &lamX, const CH_Matrix_Classes::Matrix &vecX, CH_Matrix_Classes::Real trace_bound, bool cautious) const
	try to determine the number of active eigenvalues / the dimension of the active eigenspace of X

int	get_growth (const CH_Matrix_Classes::Matrix &lamX, const CH_Matrix_Classes::Matrix &vecX, CH_Matrix_Classes::Real &growthrate, CH_Matrix_Classes::Matrix &primalgrowth, CH_Matrix_Classes::Matrix &dualgrowth) const
	compute the change rates of the Ritz values to vecX for primal and dual sides over the last two iterations

int	form_B (CH_Matrix_Classes::Integer dim, const MinorantBundle &globalbundle, CH_Matrix_Classes::Integer startindex_bundle)
	extract the local matrix B in suitable form from the bundle information

int	sveciB_times_vec (const CH_Matrix_Classes::Matrix &vec, CH_Matrix_Classes::Matrix &Bvec)
	the columns of B are the svec representation of symmetric matrics. Store in the columns of Bvec the results of multiplying the symmetric matrices by vec

Private Attributes
CH_Matrix_Classes::Matrix	B
	matrix representation of bundle

CH_Matrix_Classes::Matrix	Boffset
	columnvector of bundle offsets

CH_Matrix_Classes::Matrix	sqrBnorms
	if rowdim>0 it holds the squared norm of each subgradient in the same sequence as in B

CH_Matrix_Classes::Indexmatrix	Bnzcolind
	holds the indices of nonzero columns of B in increasing order

QPPSCOracleDataObject *	oracle_data
	if not NULL this makes the data of the underlying psc oracle accessible; it is yet to be explored whether this can help

CH_Matrix_Classes::Matrix	testmat
	for comparisons in testing

Additional Inherited Members
Protected Member Functions inherited from ConicBundle::InteriorPointBlock
int	pol_le_zero_step (CH_Matrix_Classes::Real &stepsize, CH_Matrix_Classes::Real q0, CH_Matrix_Classes::Real q1, CH_Matrix_Classes::Real q2, CH_Matrix_Classes::Real q3, CH_Matrix_Classes::Real q4, CH_Matrix_Classes::Real abseps=1e-10) const
	for a polynomial q0+alpha(q1+alpha(q2+alpha(q3+alphaq4))) with q0<=0 find the maximum alpha <= stepsize, that keeps its value <=0. and put stepsize=min(stepsize,alpha)

int	minimize_pol_step (CH_Matrix_Classes::Real &stepsize, CH_Matrix_Classes::Real q0, CH_Matrix_Classes::Real q1, CH_Matrix_Classes::Real q2, CH_Matrix_Classes::Real q3, CH_Matrix_Classes::Real q4, CH_Matrix_Classes::Real abseps=1e-10) const
	find the minimizing alpha of a polynomial q0+alpha(q1+alpha(q2+alpha(q3+alphaq4))) within 0<=alpha<=stepsize and put stepsize=alpha, where q1 is assumed to be <0 or be ==0 becoming negative for small alpa>=0.

int	control_nbh_step (CH_Matrix_Classes::Real &stepsize, CH_Matrix_Classes::Real &max_nbh, CH_Matrix_Classes::Real nbh_ubnd, CH_Matrix_Classes::Real mu_xz, CH_Matrix_Classes::Real mu_xdzpdxz, CH_Matrix_Classes::Real mu_dxdz, CH_Matrix_Classes::Real nrmsqr_xz, CH_Matrix_Classes::Real nrmsqr_xdzpdxz, CH_Matrix_Classes::Real nrmsqr_dxdz, CH_Matrix_Classes::Real ip_xz_xdzpdxz, CH_Matrix_Classes::Real ip_xz_dxdz, CH_Matrix_Classes::Real ip_dxdz_xdzpdxz) const
	find a stepsize so that outside the nbh_ubnd some progress is made towards it and inside the upper bound the step size is chosen as large as possible while staying within

Protected Member Functions inherited from ConicBundle::PSCIPBlock
void	point_changed ()
	clear variables that are no longer valid for the current point

int	compute_NTscaling ()
	computes the NT scaling information for building the system matrix

int	compute_Weig_Wvec ()
	compute Weig and Wvec with Weig eigenvalues of W and W=WvecWvec' where Wvec = PLambda^{.5} for W = PLambdaP'

Protected Attributes inherited from ConicBundle::InteriorPointBundleBlock
CH_Matrix_Classes::Integer	bundle_dim
	dimension of the bundle (in case of subspace projections this may differ from vecdim

CH_Matrix_Classes::Matrix	diff_model
	negative evaluation of minorants in current point

Protected Attributes inherited from ConicBundle::PSCIPBlock
CH_Matrix_Classes::Integer	rowdim
	order of the symmetric matrices of the cone,

CH_Matrix_Classes::Integer	vecdim
	dimension svec representation

CH_Matrix_Classes::Symmatrix	X
	"primal" point X

CH_Matrix_Classes::Symmatrix	Z
	"dual" point Z

CH_Matrix_Classes::Symmatrix	dX
	current step for X

CH_Matrix_Classes::Symmatrix	dZ
	current step for Z

CH_Matrix_Classes::Symmatrix	W
	NT scaling matrix.

CH_Matrix_Classes::Symmatrix	Winv
	inverse of NT scaling matrix

CH_Matrix_Classes::Matrix	G
	Gram Matrix of NT scaling matrix.

CH_Matrix_Classes::Matrix	Ginv
	Gram Matrix of inverse NT scaling matrix.

CH_Matrix_Classes::Matrix	D
	Diagonal for NT scaling.

CH_Matrix_Classes::Matrix	Weig
	eigenvalues of W (if Weig.rowdim()==rowdim(), lazy evaulation)

CH_Matrix_Classes::Matrix	Wvec
	W=WvecWvec' where Wvec = PLambda^{.5} for W = PLambdaP' (if Weig.rowdim()==rowdim(), lazy evaulation)

CH_Matrix_Classes::Symmatrix	compl_rhs
	rhs used in solving the complementarity line

CH_Matrix_Classes::Real	last_rhs_mu
	the last mu used in rhs computations

CH_Matrix_Classes::Real	mu
	in a step mu gets the value of last_rhs_mu

CH_Matrix_Classes::Real	old_mu
	in a step old_mu gets the value of mu before this gets last_rhs_mu

CH_Matrix_Classes::Real	last_alpha
	last alpha used in do_step()

CH_Matrix_Classes::Symmatrix	oldX
	point before x

CH_Matrix_Classes::Symmatrix	oldZ
	point before z

CH_Matrix_Classes::Matrix	lamX
	eigenvalues of X corresponding to PX (if computed)

CH_Matrix_Classes::Matrix	PX
	eigenvectors of X corresponding to lamX (if computed)

CH_Matrix_Classes::Symmatrix	tmpsym
	temporary matrices for reuse

CH_Matrix_Classes::Symmatrix	tmpsym2
	temporary matrices for reuse

CH_Matrix_Classes::Matrix	tmpvec
	temporary matrices for reuse

CH_Matrix_Classes::Matrix	tmpmat
	temporary matrices for reuse

Detailed Description

interior point variables and routines specific to the primal dual complementarity conditions of a positive semidefinite cone with special routines for handling the bundle and the trace constraint

adds bundle functionality to PSCIPBlock

Member Function Documentation

◆ add_bundle_xizinv_diagonal()

virtual int ConicBundle::PSCIPBundleBlock::add_bundle_xizinv_diagonal	(	CH_Matrix_Classes::Matrix &	diagonal,
		CH_Matrix_Classes::Matrix &	ipBtrvec,
		MinorantBundle &	globalbundle,
		CH_Matrix_Classes::Integer	startindex_bundle,
		const CH_Matrix_Classes::Matrix &	trafotrace,
		CH_Matrix_Classes::Integer	startindex_trace
	)

virtual

add diag(Bt*sqrt(invsys)*(I-lambda*trvec*trvec')*sqrt(invsys)*B) to diagonal

Parameters

[out]	diagonal	add the diagonal entries diag(BtinvsysB) here
[out]	ipBtrvec	add the vector Btsqrt(invsys)trvec here
[in]	globalbundle	the bundle vectors are [startindex_bundle ... startindex_bundle+vecdim()-1]
[in]	startindex_bundle	see globalbundle
[in]	trafotrace	holds precomputed invsys^(.5)*trace in coordinates [startindex_trace ... startindex_trace+vecdim()-1]
[in]	startindex_trace	beginning of local trace within trafotracevec

Implements ConicBundle::InteriorPointBundleBlock.

◆ add_pcsubspace()

virtual int ConicBundle::PSCIPBundleBlock::add_pcsubspace	(	CH_Matrix_Classes::Matrix &	lowrank,
		CH_Matrix_Classes::Matrix &	sigma_guess,
		const CH_Matrix_Classes::Matrix &	Diag_inv,
		CH_Matrix_Classes::Real	minval,
		CH_Matrix_Classes::Real	diaginvval,
		CH_Matrix_Classes::Matrix &	minus_trmult,
		CH_Matrix_Classes::Real	schur_trace,
		MinorantBundle &	globalbundle,
		CH_Matrix_Classes::Integer	startindex_bundle
	)

virtual

append to lowrank "large" columns that should serve well for generating a low rank projection of the Schur complemented model part. For each column i the coordinate sigma_guess(i) gives the Diag_inv-norm for this column. The parameter minval asks to ignore columns whose norms are smaller than minval. If diaginvval is positive, the vector Diag_inv is this value times the all ones vector.

On input lowrank must have the correct number of rows already but may have 0 columns.

For most new columns of lowrank it will be necessary to subtract the same tracevector-column according to the inner product of the column stored in minus_trmult, so for each new column the inner product of the generating vector with tracevector has to be appended to minus_trmult.

Implements ConicBundle::InteriorPointBundleBlock.

◆ Schur_transform_bundle()

int ConicBundle::PSCIPBundleBlock::Schur_transform_bundle	(	CH_Matrix_Classes::Matrix &	glob_lowrank,
		MinorantBundle &	globalbundle,
		CH_Matrix_Classes::Integer	startindex_bundle,
		CH_Matrix_Classes::Matrix &	trafotrace,
		CH_Matrix_Classes::Integer	startindex_trace
	)

virtual

provides basic information for low rank preconditioning (in the extreme case solving) for the case of Schur complementing the model and the trace into the quadratic block

Parameters

[in]	glob_lowrank	set the low rank contribution Bt*invsys^(.5) without considering the correction for the trace vector for the columns startindex_bundle ... startindex_bundle+vecdim()-1
[in]	globalbundle	only input for forming Bt if needed
[in]	startindex_bundle	input for forming Bt together with globalbundle and column positions within glob_lowrank
[in]	trafotrace	put invsys^(.5)*trace in coordinates startindex_trace ... startindex_trace+vecdim()-1
[in]	startindex_trace	beginning of local trace within trafotracevec

Implements ConicBundle::InteriorPointBundleBlock.

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

PSCIPBundleBlock.hxx

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ add_bundle_xizinv_diagonal()

◆ add_pcsubspace()

◆ Schur_transform_bundle()