ConicBundle
Public Member Functions | Private Member Functions | Private Attributes | List of all members
ConicBundle::PSCIPBundleBlock Class Reference

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:
ConicBundle::InteriorPointBundleBlock ConicBundle::PSCIPBlock ConicBundle::InteriorPointBlock ConicBundle::InteriorPointBlock ConicBundle::CBout ConicBundle::CBout

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 InteriorPointBundleBlockclone ()
 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::MatrixB_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=beta*C+alpha*B*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::Matrixtimes_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=beta*C+alpha*A*B where B and B may be transposed; carry out the model part of this beginning at startindex_model.
 
virtual CH_Matrix_Classes::Symmatrixadd_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)*diagvec*projection to bigS starting at startindex
 
virtual CH_Matrix_Classes::Matrixget_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+alpha*dx, z+alpha*dz), 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(Bt*sqrt(invsys)*(I-lambda*trvec*trvec')*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 bundle*sqrt(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=rhsmu*xi-rhscorr*xi*dx*dz (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+alpha*dx, z+alpha*dz)
 
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
 
QPPSCOracleDataObjectoracle_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+alpha*q4))) 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+alpha*q4))) 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=Wvec*Wvec' where Wvec = P*Lambda^{.5} for W = P*Lambda*P'
 
- 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=Wvec*Wvec' where Wvec = P*Lambda^{.5} for W = P*Lambda*P' (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]diagonaladd the diagonal entries diag(Bt*invsys*B) here
[out]ipBtrvecadd the vector Bt*sqrt(invsys)*trvec here
[in]globalbundlethe bundle vectors are [startindex_bundle ... startindex_bundle+vecdim()-1]
[in]startindex_bundlesee globalbundle
[in]trafotraceholds precomputed invsys^(.5)*trace in coordinates [startindex_trace ... startindex_trace+vecdim()-1]
[in]startindex_tracebeginning 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_lowrankset 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]globalbundleonly input for forming Bt if needed
[in]startindex_bundleinput for forming Bt together with globalbundle and column positions within glob_lowrank
[in]trafotraceput invsys^(.5)*trace in coordinates startindex_trace ... startindex_trace+vecdim()-1
[in]startindex_tracebeginning of local trace within trafotracevec

Implements ConicBundle::InteriorPointBundleBlock.


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