SOCSupportFunction.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_SOCSUPPORTFUNCTION_HXX
#define CONICBUNDLE_SOCSUPPORTFUNCTION_HXX

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

#include <map>
#include "SOCSupportModification.hxx"
#include "SOCOracle.hxx"

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

namespace ConicBundle {


  class SOCSupportFunction;

  class SOCSupportMinorantExtender: public CBout, public MinorantExtender
  {
  private:
    SOCSupportFunction* fun;

  public:
    SOCSupportMinorantExtender(SOCSupportFunction* fun);
                        
    ~SOCSupportMinorantExtender();

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

        for each relevant index i the minorant value is set to the projection 
        of 0 onto the interval [lower_bound(i),upper_bound(i)]

        @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() 

        @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 SOCSupportFunction: public SOCOracle, public CBout
  {
  private:
    CH_Matrix_Classes::Integer socdim;
    
    int apply_modification(const SOCSupportModification& mod);
    
  public:

    SOCSupportFunction(CH_Matrix_Classes::Integer socdim,const CBout* cb=0,int incr=-1);    

    ~SOCSupportFunction(){}


    //----------- Oracle Implementation of SOCOracle ----------

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

    int extract_SOCvector(CH_Matrix_Classes::Matrix& SOCvec, const Minorant* SOCminorant);
    
    int projection(CH_Matrix_Classes::Matrix& offset,
                   CH_Matrix_Classes::Matrix& coeffs,
                   const CH_Matrix_Classes::Matrix& bar_P,
                   const CH_Matrix_Classes::Indexmatrix* index_subset=0);
    
    virtual
    int
    evaluate
    (
     const CH_Matrix_Classes::Matrix& current_point,
     const CH_Matrix_Classes::Real relprec,
     CH_Matrix_Classes::Real& SOC_value,
     CH_Matrix_Classes::Matrix& SOC_vector,
     SOCPrimalExtender*& primal_extender 
     );

    virtual
    int
    evaluate_projection
    (
     const CH_Matrix_Classes::Matrix& current_point,
     const CH_Matrix_Classes::Matrix& P, 
     const CH_Matrix_Classes::Real relprec,
     CH_Matrix_Classes::Real& projected_SOC_value
     );


    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 true;}
    

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

    CH_Matrix_Classes::Integer get_socdim() { return socdim;}
    
            


   //------------------  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