implements a (virtual) cutting model being built of a (possibly recursive) sum of QPModelBlock cutting model instances for QPSolver More...
#include <QPSumModelBlock.hxx>
Inheritance diagram for ConicBundle::QPSumModelBlock:
Public Member Functions | |
| void | clear () |
| reset to "empty/no" model | |
| QPSumModelBlock (CBout *cb=0, int cbincr=-1) | |
| default constructor | |
| virtual | ~QPSumModelBlock () |
| virtual destructor | |
| virtual QPModelBlockObject * | clone () |
| return a cloned object on the heap | |
| virtual void | recursive_delete_and_clear () |
| usually the objects of the recursive block structure and not deleted in a clear. If needed, this can be invoked explicitly here, e.g., in order to clean up clones | |
| virtual int | recursive_copy_data_of (QPModelBlockObject *) |
| sofar this is only needed for some comparative evaluations | |
| int | append (QPModelDataObject *inblock) |
| add another model at the end of the list | |
| 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=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::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=beta*C+alpha*A*B where A 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)*diagvec*projection 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 | get_modelx (CH_Matrix_Classes::Matrix &modelx, CH_Matrix_Classes::Integer startindex_model) |
| set the local modelx value in modelx beginning with startindex (initialize it, do not add) | |
| virtual int | get_modeldx (CH_Matrix_Classes::Matrix &modeldx, CH_Matrix_Classes::Integer startindex_model) |
| set the local modeldx value in modeldx beginning with startindex (initialize it, do not add) | |
| virtual int | get_modeldcstr (CH_Matrix_Classes::Matrix &modeldcstr, CH_Matrix_Classes::Integer startindex_constraints) |
| set the local modeldcstr value in modeldcstr beginning with startindex (initialize it, do not add) | |
| 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 &modelvec, CH_Matrix_Classes::Integer startindex_model, const CH_Matrix_Classes::Matrix &dy, MinorantBundle &global_bundle, CH_Matrix_Classes::Integer startindex_bundle) |
| set the model violation for the current system solution | |
| virtual int | get_sysviol_constraints (CH_Matrix_Classes::Matrix &constrvec, CH_Matrix_Classes::Integer startindex_constr) |
| set the constraint violation for the current system solution starting at this index | |
| virtual void | display_model_values (const CH_Matrix_Classes::Matrix &y, MinorantBundle &global_bundle, CH_Matrix_Classes::Integer startindex_bundle, std::ostream &out) |
| output for debbuging purposes | |
| virtual int | reset_starting_point (const CH_Matrix_Classes::Matrix &y, CH_Matrix_Classes::Real mu, MinorantBundle &global_bundle, CH_Matrix_Classes::Integer startindex_bundle) |
| reset the starting point for this value of the design variables y | |
| virtual int | compute_step (const CH_Matrix_Classes::Matrix &ystep, MinorantBundle &global_bundle, CH_Matrix_Classes::Integer startindex_bundle) |
| compute the step in the model space given the step in the design space | |
| virtual int | computed_step (const CH_Matrix_Classes::Matrix &modelxstep, CH_Matrix_Classes::Integer startindex_model, const CH_Matrix_Classes::Matrix &modelconstrstep, CH_Matrix_Classes::Integer startindex_constr) |
| store this computed step locally and compute the missing local dual step information | |
| virtual int | do_step (CH_Matrix_Classes::Real alpha, const CH_Matrix_Classes::Matrix &y, MinorantBundle &global_bundle, CH_Matrix_Classes::Integer startindex_bundle) |
| move in the last computed step direction by a step of length alpha and compute and store the violation in this point for later use in | |
| virtual int | add_localrhs (CH_Matrix_Classes::Matrix &globalrhs, CH_Matrix_Classes::Real rhsmu, CH_Matrix_Classes::Real rhscorr, CH_Matrix_Classes::Integer startindex_model, CH_Matrix_Classes::Integer startindex_constraints, bool append, MinorantBundle &bundle, CH_Matrix_Classes::Integer startindex_bundel) |
| If mu is not zero, always add the centering term for this mu as well, if append is false, add the Schur complement rhs for add_BtinvsysB, if append is true, fill in the rhs of the local system starting at startindex for the model and at startindex_constraints for the modelconstraints. | |
| virtual int | add_BtinvsysB (CH_Matrix_Classes::Symmatrix &globalsys, 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 | |
| virtual int | solve_constrsys (const CH_Matrix_Classes::Symmatrix &ABchol, const CH_Matrix_Classes::Matrix &LinvABrhs, CH_Matrix_Classes::Matrix &LinvABsol, CH_Matrix_Classes::Integer startindex_model, CH_Matrix_Classes::Matrix &Crhs_and_sol, CH_Matrix_Classes::Integer startindex_constraints) |
| given the Cholesky factorization LL' of minus the blocks A and B (contraints on design variables and Bundle-modelx) and LinvABrhs, solve for the local constraints C and add the new contribution of tracedual*LinvTrace to LinvABsol; store the tracedual in Crhs_and_sol but not yet locally (this will be done by computed_step() ). | |
| virtual int | add_BCSchur_diagonal (CH_Matrix_Classes::Matrix &diagonal, MinorantBundle &globalbundle, CH_Matrix_Classes::Integer startindex_bundle) |
| add the diagonal of the Schur complemented blocks belonging to bundle and local constraints (used for diagonal preconditioning) | |
| virtual int | propose_BCSchur_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, 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... | |
| virtual int | prepare_BCSchur_JLprecond (CH_Matrix_Classes::Matrix &glob_lowrank, CH_Matrix_Classes::Matrix &subspace, bool append_globtransp_times_mat_to_subspace, MinorantBundle &globalbundle, CH_Matrix_Classes::Integer startindex_bundle) |
| compute the preconditioning low-rank representation of the Schur complementd blocks belonging to bundle and local constraints by adding a Johnson-Lindenstrauss projection onto the given subspace to glob_lowrank More... | |
| virtual int | add_Schur_rhs (CH_Matrix_Classes::Matrix &glob_rhs, CH_Matrix_Classes::Matrix *local_rhs, CH_Matrix_Classes::Real rhsmu, CH_Matrix_Classes::Real rhscorr, CH_Matrix_Classes::Integer startindex_constraints, MinorantBundle &globalbundle, CH_Matrix_Classes::Integer startindex_bundle) |
| add the contributions to glob_rhs of the Schur complemented model block, and return local_rhs of the non complemented constraint block in the rows/columns/diagonal block starting at startindex_constraints | |
| virtual int | add_Schur_mult (const CH_Matrix_Classes::Matrix &in_vec, CH_Matrix_Classes::Matrix &out_vec, const CH_Matrix_Classes::Matrix *in_cvec, CH_Matrix_Classes::Matrix *out_cvec, CH_Matrix_Classes::Integer startindex_constraints, MinorantBundle &globalbundle, CH_Matrix_Classes::Integer startindex_bundle) |
| multiply in_vec with the local contribution to the global main block and add it to out_vec; the other local multiplications are carried out externally with the information provide in prepare_Schur_precond and are not done here. | |
| virtual int | computed_Schur_step (const CH_Matrix_Classes::Matrix &xstep, const CH_Matrix_Classes::Matrix &local_step, CH_Matrix_Classes::Integer startindex_model, MinorantBundle &globalbundle, CH_Matrix_Classes::Integer startindex_bundle) |
| for passing on the solution information after solvin the system | |
| virtual CH_Matrix_Classes::Integer | dim_model () |
| returns the dimension of the model set (here the same as the bundle size) | |
| virtual CH_Matrix_Classes::Integer | dim_constraints () |
| returns the dimension of the system describing the model set (may contain further constraints) | |
| virtual CH_Matrix_Classes::Real | constraints_cost (void) |
| returns the dual upper bound to the model value (the trace weighted sum of the dual trace variables); it returns 0. if no model is contained | |
| virtual CH_Matrix_Classes::Real | primalviol_2normsqr () |
| return the squared Euclidean norm of constraint violation of modelx | |
| virtual CH_Matrix_Classes::Real | dualviol_2normsqr () |
| return the squared Euclidean norm of the dual model violation | |
| 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_localsys (CH_Matrix_Classes::Symmatrix &globalsys, CH_Matrix_Classes::Integer startindex_model, CH_Matrix_Classes::Integer startindex_constraints) |
| add the "scaled" minorant outer products to globalsys, | |
| virtual int | localsys_mult (const CH_Matrix_Classes::Matrix &in_vec, CH_Matrix_Classes::Matrix &out_vec, CH_Matrix_Classes::Integer startindex_model, CH_Matrix_Classes::Integer startindex_constraints) |
| multiply the local system diagonal block consisting of the model and local contraints rows and columns by in_vec[startindex_model+0,...,+dim_model(),startindex_constraints+0,...,+dim_constraints] into the same coordinates of out_vec. | |
 Public Member Functions inherited from ConicBundle::QPModelBlock | |
| QPModelBlock (CBout *cb=0, int cbinc=-1) | |
| default constructor | |
| virtual | ~QPModelBlock () |
| virtual destructor | |
| virtual const MinorantPointer & | get_constant_minorant () const |
| gives reading access to a constant offset minorant | |
| virtual const MinorantBundle & | get_bundle () const |
| gives reading access to the bundle minorants of the cutting model | |
| virtual MinorantPointer & | get_constant_minorant () |
| gives access to a constant offset minorant | |
| virtual MinorantBundle & | get_bundle () |
| gives access to the bundle minorants of the cutting model | |
| virtual int | push_aft (const AffineFunctionTransformation *inaft, const CH_Matrix_Classes::Indexmatrix *global_indices, const CH_Matrix_Classes::Indexmatrix *local_indices, std::map< MinorantPointer, MinorantPointer > *precomputed=0) |
| applies the AffineFunctionTransformation to constant_minorant and bundle, where (if given) only the global_indices of the transformed subgradients are required which need the local_indices only. If precomputed is given, it may contain some or contains afterwards a map from original minorant to transformed minorant; retunrs 0 on success | |
| virtual int | pop_aft () |
| undo the last push_aft | |
| virtual CH_Matrix_Classes::Integer | dim_bundle () |
| returns bundle.size() of the model (may differ from dim_model in case of fixing some subspace to zero) | |
| virtual CH_Matrix_Classes::Real | globalx_cost (const CH_Matrix_Classes::Matrix &globalx) |
| returns the value of constant offset plus global linear cost term for the current globalx | |
| virtual int | add_modelx_aggregate (CH_Matrix_Classes::Real &val, CH_Matrix_Classes::Matrix &vec) |
| adds opB transposed times modelx and constant affine term to the arguments | |
| virtual int | add_Bt_modelx (CH_Matrix_Classes::Real &val, CH_Matrix_Classes::Matrix &vec) |
| adds opB transposed times modelx and constant affine term to the arguments | |
| virtual CH_Matrix_Classes::Matrix & | B_times (const CH_Matrix_Classes::Matrix &A, CH_Matrix_Classes::Matrix &C, CH_Matrix_Classes::Real alpha=1., CH_Matrix_Classes::Real beta=0., int Btrans=0, int Atrans=0) |
| computes and returns C=alpha*B*A+beta*C where B and A may be transposed; C needs to have the correct size on input but will be initialized if beta==0. | |
| virtual CH_Matrix_Classes::Matrix & | times_B (const CH_Matrix_Classes::Matrix &A, CH_Matrix_Classes::Matrix &C, CH_Matrix_Classes::Real alpha=1., CH_Matrix_Classes::Real beta=0., int Atrans=0, int Btrans=0) |
| computes and returns C=alpha*A*(B)+beta*C where A and B may be transposed; C needs to have the correct size on input but will be initialized if beta==0. | |
| virtual CH_Matrix_Classes::Symmatrix & | add_BDBt (const CH_Matrix_Classes::Matrix &diagvec, CH_Matrix_Classes::Symmatrix &S, bool minus=false, CH_Matrix_Classes::Integer startindex=0) |
| add B*Diag(diagvec)*Bt to S in the principal block starting at startindex | |
| virtual CH_Matrix_Classes::Matrix & | get_Bt (CH_Matrix_Classes::Matrix &Bt, CH_Matrix_Classes::Integer start_col=0) |
| store the coupling matrix Bt (first block row in the system) starting at column start_col (enlarge Bt first if start_col==Bt.coldim(), but the row dimension must be correct) | |
| virtual CH_Matrix_Classes::Matrix & | get_x () |
| get the vector formed by all model x variables | |
| virtual CH_Matrix_Classes::Matrix & | get_dx () |
| get the vector formed by all delta model x variables | |
| virtual CH_Matrix_Classes::Matrix & | get_dcstr () |
| get the vector formed by all delta model x variables | |
| virtual CH_Matrix_Classes::Matrix & | get_sysviol_model (const CH_Matrix_Classes::Matrix &dy) |
| get the model violation for the current system solution | |
| virtual CH_Matrix_Classes::Matrix & | get_sysviol_constraints () |
| get the constraint violation for the current system solution | |
| virtual void | display_model_values (const CH_Matrix_Classes::Matrix &y, std::ostream &out) |
| for test outputs | |
| int | reset_starting_point (const CH_Matrix_Classes::Matrix &y, CH_Matrix_Classes::Real mu) |
| initialize the model variables to a strictly feasible "central" starting point; this is the first call when the next QP problem is solved, so other initialization steps may be appropriate as well here. | |
| int | compute_step (const CH_Matrix_Classes::Matrix &ystep) |
| compute the step in the model space given the step in the design space | |
| int | computed_step (const CH_Matrix_Classes::Matrix &modelxstep, const CH_Matrix_Classes::Matrix &modelconstrstep) |
| store the computed step and compute the missing dual step information | |
| int | do_step (CH_Matrix_Classes::Real alpha, const CH_Matrix_Classes::Matrix &nexty) |
| move in the last computed step direction by a step of length alpha | |
| int | add_localrhs (CH_Matrix_Classes::Matrix &globalrhs, CH_Matrix_Classes::Real rhsmu, CH_Matrix_Classes::Real rhscorr, CH_Matrix_Classes::Integer startindex_model, CH_Matrix_Classes::Integer startindex_constraints, bool append) |
| if mu is not zero, always add the centering term for this mu as well, if append is false, add the Schur complement rhs for add_BtinvsysB, if append is true, append the rhs of the local system | |
| int | add_BtinvsysB (CH_Matrix_Classes::Symmatrix &globalsys) |
| add the "scaled" minorant outer products to globalsys | |
| virtual int | solve_constrsys (const CH_Matrix_Classes::Symmatrix &ABchol, CH_Matrix_Classes::Matrix &ABCrhs_and_sol, CH_Matrix_Classes::Integer startindex_model, CH_Matrix_Classes::Integer startindex_constraints) |
| given the Cholesky factorization LL' of minus the blocks A and B (contraints on design variables and Bundle-modelx), solve for the local constraints C and then for AB and return the solution to the ABC-variables without storing them yet (this will be done by computed_step() ). | |
| virtual int | add_BCSchur_diagonal (CH_Matrix_Classes::Matrix &diagonal) |
| add the diagonal of the Schur complemented blocks belonging to bundle and local constraints (used for diagonal preconditioning) | |
| virtual int | propose_BCSchur_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=-1.) |
| 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... | |
| virtual int | prepare_BCSchur_JLprecond (CH_Matrix_Classes::Matrix &glob_lowrank, CH_Matrix_Classes::Matrix &subspace, bool append_globtransp_times_mat_to_subspace=false) |
| compute the preconditioning low-rank representation of the Schur complementd blocks belonging to bundle and local constraints by adding a Johnson-Lindenstrauss projection onto the given subspace to glob_lowrank More... | |
| virtual int | add_Schur_rhs (CH_Matrix_Classes::Matrix &glob_rhs, CH_Matrix_Classes::Matrix *local_rhs, CH_Matrix_Classes::Real rhsmu, CH_Matrix_Classes::Real rhscorr) |
| add the contributions to glob_diagonal and glob_rhs of the Schur complemented parts, and return local_rhs, local_globblock, local_diagblock of the non complemented parts | |
| virtual int | add_Schur_mult (const CH_Matrix_Classes::Matrix &in_Qvec, CH_Matrix_Classes::Matrix &out_Qvec, const CH_Matrix_Classes::Matrix *in_Cvec=0, CH_Matrix_Classes::Matrix *out_Cvec=0) |
| multiply in_vec with the local contribution to the global main block and add it to out_vec; the other local multiplications are carried out externally with the information provide in prepare_Schur_precond and are not done here. | |
| virtual int | computed_Schur_step (const CH_Matrix_Classes::Matrix &xstep, const CH_Matrix_Classes::Matrix &local_step) |
| use the computed step information to also compute the steps of the complemented parts | |
| Public Member Functions inherited from ConicBundle::QPModelDataObject | |
| QPModelDataObject (CBout *cb=0, int cbinc=-1) | |
| default constructor | |
| virtual | ~QPModelDataObject () |
| virtual destructor | |
| 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::QPSumModelDataObject | |
| QPSumModelDataObject (CBout *cb=0, int cbinc=-1) | |
| default constructor | |
| virtual | ~QPSumModelDataObject () |
| virtual destructor | |
Private Attributes | |
| std::vector< QPModelBlock * > | blocks |
| the container pointing to the QPModelBlock instances comprised in the sum | |
| CH_Matrix_Classes::Integer | modeldim |
| the joint dimension of the modle, may change after any change of the point | |
| CH_Matrix_Classes::Integer | constrdim |
| the joint number of constraints within the models, this may change after any change of the point | |
Additional Inherited Members | |
| Protected Member Functions inherited from ConicBundle::QPModelBlock | |
| virtual void | modelx_changed () |
| whenever modelx is (going to be) changed, the information collected for the oblivious modelx is reset to "empty" here | |
| Protected Attributes inherited from ConicBundle::QPModelBlock | |
| std::vector< MinorantPointer > | constant_minorant |
| constant offset minorant (fixed affine function to be added to the model); each aft creates a new one with push_back | |
| std::vector< MinorantBundle > | bundle |
| the minorants forming the cutting model(s); how to combine them within the model(s) comprised in *this is described in derived classes; each aft creates a new one with push_back | |
| CH_Matrix_Classes::Matrix | modelx |
| the current vector of model variables of all models comprised in *this | |
| CH_Matrix_Classes::Matrix | Bt |
| if the matrix of the bundle information has to be formed at least once, it is then stored here for later use | |
| CH_Matrix_Classes::Matrix | modeldx |
| only for testing | |
| CH_Matrix_Classes::Matrix | modeldcstr |
| only for testing | |
| CH_Matrix_Classes::Matrix | sysviol_model |
| only for testing | |
| CH_Matrix_Classes::Matrix | sysviol_constraints |
| only for testing | |
| MinorantPointer | modelx_aggregate |
| if asked to form the aggregate for the current modlex, it is also stored here for later use | |
Detailed Description
implements a (virtual) cutting model being built of a (possibly recursive) sum of QPModelBlock cutting model instances for QPSolver
Note, the bundle at the final level might not be the same as the one in the recursive calls, because it might have undergone an AffineFunctionTransformation.
Not much is happening here besides passing on the calls to the various submodels with information on where to find its own (possibly transformed) bundle information and where to store the requested information in respective global objects
Member Function Documentation
◆ prepare_BCSchur_JLprecond()
|
virtual |
compute the preconditioning low-rank representation of the Schur complementd blocks belonging to bundle and local constraints by adding a Johnson-Lindenstrauss projection onto the given subspace to glob_lowrank
Implements ConicBundle::QPModelBlock.
◆ propose_BCSchur_pcsubspace()
|
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.
Implements ConicBundle::QPModelBlock.
The documentation for this class was generated from the following file:
