PSCAffineFunction.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_PSCAFFINEFUNCTION_HXX
#define CONICBUNDLE_PSCAFFINEFUNCTION_HXX

//------------------------------------------------------------

#include <map>
#include "PSCOracle.hxx"
#include "PSCPrimal.hxx"
#include "Bigmatrix.hxx"
#include "PSCAffineModification.hxx"

//------------------------------------------------------------

namespace ConicBundle {


  class PSCAffineFunction;

  class PSCAffineMinorantExtender: public CBout, public MinorantExtender
  {
  private:
    PSCAffineFunction* amf;

  public:
    PSCAffineMinorantExtender(PSCAffineFunction* amf);
                        
    ~PSCAffineMinorantExtender();

    /*@brief called by ConicBundle to update internal Minorant objects, has to return 0 on success

        @param[in,out] minorant  (Minorant&)
            it holds a (possibly aggregated) minorant that was generated
            from minorants returned by oracle calls, e.g. as in 
            FunctionOracle::evaluate() If PrimalData was provided in these
            minorants, this will be aggregated along and will also be 
            available in this minorant.

        @param[in] n_coords (int)
            the number of coordinate positions that have to be filled in

        @param[out] new_subgradient_values  (DVector &)
            the indices of these coordinate positions (sorted in
            strictly increasing order)
      
        @return
           -  0 on success,
           -  1 if extension/update is impossible 
      
     */ 
    int extend(Minorant& minorant,int n_coords,const int* indices);

  };



  class AMFMaxEigSolver;

  class PSCAffineFunction: public PSCOracle, public CBout
  {
  private:
    SparseCoeffmatMatrix C; 

    SparseCoeffmatMatrix opAt;  

    PSCPrimal* generating_primal; 
    
    std::vector<AMFMaxEigSolver*> maxeigsolver; 

    CH_Matrix_Classes::Matrix last_bigmat_y;  

    CH_Matrix_Classes::Integer maxvecs; 

    bool check_correctness_flag; 

    int form_bigmatrix(const CH_Matrix_Classes::Matrix& current_point);

    int apply_modification(const PSCAffineModification& amfmod);
    
    void clear();

  public:
    PSCAffineFunction(const CBout* cb=0,int incr=-1);

    PSCAffineFunction(const SparseCoeffmatMatrix& C,
                         const SparseCoeffmatMatrix& opAt,
                         PSCPrimal* generating_primal=0,
                         const CBout* cb=0,int incr=-1);

    ~PSCAffineFunction();


    void set_check_correctness(bool chk)
    {check_correctness_flag=chk;}

    void set_max_Ritzvecs(CH_Matrix_Classes::Integer maxv)
    {maxvecs=(maxv>1)?maxv:5;}


    //----------- Oracle Implementation of PSCOracle ----------

    Minorant* generate_minorant(const CH_Matrix_Classes::Matrix& P);

    int svec_projection(CH_Matrix_Classes::Matrix& svec_offset,
                        CH_Matrix_Classes::Matrix& svec_coeffs,
                        const CH_Matrix_Classes::Matrix& P,
                        const CH_Matrix_Classes::Indexmatrix* index_subset=0);

    

    int evaluate(const CH_Matrix_Classes::Matrix& current_point, 
                 const CH_Matrix_Classes::Matrix& bundlevecs, 
                 const double relprec,
                 const double Ritz_bound,
                 CH_Matrix_Classes::Matrix& Ritz_vectors,
                 CH_Matrix_Classes::Matrix&  Ritz_values,
                 PSCPrimalExtender*& primal_extender);

    int evaluate_projection(const CH_Matrix_Classes::Matrix& current_point, 
                            const CH_Matrix_Classes::Matrix& P, 
                            const double relprec,
                            CH_Matrix_Classes::Matrix& projected_Ritz_vectors,
                            CH_Matrix_Classes::Matrix& projected_Ritz_values);

    int left_right_product(int i, 
                           const CH_Matrix_Classes::Matrix& E,
                           const CH_Matrix_Classes::Matrix& F, 
                           CH_Matrix_Classes::Matrix& G); 


    virtual 
    int 
    apply_modification
    (
     const OracleModification& oracle_modification ,
     const CH_Matrix_Classes::Matrix* new_center,
     const CH_Matrix_Classes::Matrix* old_center,
     bool& discard_objective_in_center,
     bool& discard_model, 
     bool& discard_aggregates,
     MinorantExtender*& minorant_extender
    );

    
     virtual
    bool
    check_correctness() const
    {return check_correctness_flag;}
    

    //------------------  routines for querying the problem ----------------

    const SparseCoeffmatMatrix& get_opAt() { return opAt;}
    
    const SparseCoeffmatMatrix& get_C() {return C;}
    
    const PSCPrimal* get_generating_primal(void)
    { return generating_primal;}
        


   //------------------  routines for IO ----------------

    void  set_out(std::ostream* o=0,int pril=1);
    void  set_cbout(const CBout* cb,int incr=-1);

    std::ostream& print_problem_data(std::ostream& out) const;

    std::istream& read_problem_data(std::istream& in);

    std::ostream& print_problem_data_to_mfile(std::ostream& out, CH_Matrix_Classes::Integer blocknr) const;
    //std::istream& read_problem_data_from_mfile(std::istream& in);


  };


}


#endif