ConicBundle
Public Member Functions | Protected Member Functions | List of all members
ConicBundle::InteriorPointBlock Class Referenceabstract

abstract interface for interior point vector/matrix variables and routines specific to primal dual complementarity conditions of symmetric cones More...

#include <InteriorPointBlock.hxx>

Inheritance diagram for ConicBundle::InteriorPointBlock:
ConicBundle::CBout ConicBundle::InteriorPointBundleBlock ConicBundle::NNCIPBlock ConicBundle::PSCIPBlock ConicBundle::SOCIPBlock ConicBundle::BoxIPBundleBlock ConicBundle::NNCIPBundleBlock ConicBundle::PSCIPBundleBlock ConicBundle::SOCIPBundleBlock ConicBundle::NNCIPBundleBlock ConicBundle::PSCIPBundleBlock ConicBundle::SOCIPBundleBlock

Public Member Functions

 InteriorPointBlock (CBout *cb=0, int cbinc=-1)
 default constructor
 
virtual ~InteriorPointBlock ()
 virtual destructor (implemented in InteriorPointBundleBlock.cxx)
 
virtual CH_Matrix_Classes::Integer get_vecdim () const =0
 the dimension of the variable
 
virtual int center_x (CH_Matrix_Classes::Real val, bool add=false)=0
 set x to value*"one" to x (spend a total of mu_dim*val), or if add==true, add value*"one" to x
 
virtual int center_z (CH_Matrix_Classes::Real val, bool add=false)=0
 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)=0
 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 via center_x 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)=0
 set z to the values of vec[startindex+0,+1 ...,+(vecdim-1)] and return a value>=0 that needs to be added via center_z to make it feasible
 
virtual int vecgetsax (CH_Matrix_Classes::Matrix &vec, CH_Matrix_Classes::Integer startindex, CH_Matrix_Classes::Real a=1., bool add=false)=0
 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)=0
 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 =0
 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 =0
 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 =0
 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)=0
 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)=0
 extract dx from rhs at startindex and compute at the same time dz (=-sys dx-z +complentarity_rhs); this may only be called after add_muxinv() was called for this point
 
virtual int set_dx_xizsolverhs (const CH_Matrix_Classes::Matrix &rhs, CH_Matrix_Classes::Integer startindex)=0
 compute dx=sysinv*rhs and at the same time dz (=-rhs-z +complentarity_rhs); may only be called after add_muxinv was called for the most recent point; this may only be called after add_muxinv() was called for this point
 
virtual int apply_xizinv (CH_Matrix_Classes::Matrix &rhs, CH_Matrix_Classes::Integer startindex, bool minus=false)=0
 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)=0
 compute sys*rhs into rhs, possibly with a negative sign
 
virtual int do_step (CH_Matrix_Classes::Real alpha)=0
 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)=0
 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)=0
 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)=0
 return the vector form of x
 
virtual int get_vecz (CH_Matrix_Classes::Matrix &vecz, CH_Matrix_Classes::Integer startindex)=0
 return the vector form of z
 
virtual int get_vecdx (CH_Matrix_Classes::Matrix &vecdx, CH_Matrix_Classes::Integer startindex)=0
 return the vector form of dx, 1 if not available
 
virtual int get_vecdz (CH_Matrix_Classes::Matrix &vecdz, CH_Matrix_Classes::Integer startindex)=0
 return the vector form of dz, 1 if not available
 
- 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
 

Protected Member Functions

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
 

Detailed Description

abstract interface for interior point vector/matrix variables and routines specific to primal dual complementarity conditions of symmetric cones

This is the general part independent of the bundle framework.


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